Implement code changes to enhance functionality and improve performance

Author: wilfredinni

docs/blog/python-data-types.md

@@ -0,0 +1,269 @@
+---
+title: Python Data Types Explained - A Visual Guide for Beginners
+description: This guide provides a comprehensive overview of Python's built-in data types, their characteristics, and use cases.
+date: Jul 20, 2025
+updated: Jul 20, 2025
+tags: python, intermediate, data types
+socialImage: /blog/python-data-types.jpg
+---
+
+<route lang="yaml">
+meta:
+    layout: article
+    title: Python Data Types Explained - A Visual Guide for Beginners
+    description: This guide provides a comprehensive overview of Python's built-in data types, their characteristics, and use cases.
+    date: Jul 20, 2025
+    updated: Jul 20, 2025
+    socialImage: /blog/python-data-types.jpg
+    tags: python, intermediate, data types
+</route>
+
+<blog-title-header :frontmatter="frontmatter" title="Python data types: A visual guide for beginners" />
+
+Python comes with just eight core data types, yet choosing the right one makes code clearer, faster, and safer. The cheat-sheet below shows how each type works, when to reach for it, and where its limitations hide.
+
+![Diagram of Python built-in data type categories and mutability.](https://user-gen-media-assets.s3.amazonaws.com/gpt4o_images/aa542d99-cf60-4ae1-bf22-da20d0e0cd60.png)
+
+Diagram of Python built-in data type categories and mutability.
+
+## 1. Numbers – `int`, `float`, `complex`
+
+Python groups pure numeric types under one family but gives each a specialty.
+
+| Type      | Typical literal        | Key traits                                                                                 | When to use                                                  | Handy methods/ops                       |
+| :-------- | :--------------------- | :----------------------------------------------------------------------------------------- | :----------------------------------------------------------- | :-------------------------------------- |
+| `int`     | `42`, `0xFF`           | Unlimited precision whole numbers; supports binary `0b`, octal `0o`, hex `0x` literals[^1] | Counting, indexing, money amounts (with `decimal` for cents) | `bit_length()`, `to_bytes()`[^2]        |
+| `float`   | `3.14`, `1.2e3`        | 64-bit IEEE-754 float; rounding error possible[^3][^4]                                     | Scientific data, averages, continuous measures               | `.is_integer()`, `.hex()`, math module  |
+| `complex` | `2+3j`, `complex(a,b)` | Real + imag part; full arithmetic, `.real`, `.imag`, `.conjugate()`[^5][^6]                | DSP, fractals, impedance math                                | All arithmetic, `abs()` gives magnitude |
+
+### Quick demo
+
+```python
+radius = 2.5          # float
+area = 3.1416 * radius**2
+z = complex(2, 3)     # (2+3j)
+polar_r = abs(z)      # 3.605…
+```
+
+## 2. Strings – `str`
+
+Immutable sequences of Unicode code points.
+
+- Creation: quotes `'hi'` or `"hi"`, triple quotes for multi-line.
+- Formatting: f-strings `f"{name=}"` (fast), older `str.format`, `%` operator.
+- Common methods: `split`, `join`, `replace`, `strip`, `startswith`, `casefold` for case-insensitive compares[^7][^8][^9].
+
+Why immutability? Fast hashing (dictionary keys) and thread-safety.
+
+## 3. Booleans – `bool`
+
+Subclass of `int` with only two singletons: `True`, `False`.
+Python evaluates _truthiness_: any non-zero number, non-empty sequence, or custom object with `__bool__` → `True`; zero, empty, or `None` → `False`[^10][^11][^12].
+
+```python
+items = []
+if items:          # empty list is falsey
+    ...
+```
+
+## 4. Lists – `list`
+
+Mutable, ordered, heterogeneous collection.
+
+- Square-bracket syntax: `nums = [^13][^14][^15]`[^16].
+- Operations: `append`, `extend`, `insert`, `remove`, `pop`, slicing, list comprehension[^17][^18][^19].
+- When: ordered data you’ll mutate, stack/queue prototypes, accumulating results.
+  Performance tip: prefer `deque` for heavy pops from the left.
+
+## 5. Dictionaries – `dict`
+
+Hash-table mapping of _immutable_ keys to values; insertion-ordered since 3.7.
+
+- Literal: `movie = {"title": "Dune", "year": 2021}`
+- Methods: `get`, `items`, `keys`, `update`, `setdefault`, `pop`[^20][^21].
+- When: lookup by key (id → row), counting, memoization.
+  Use `defaultdict` or `Counter` from `collections` for common patterns.
+
+## 6. Tuples – `tuple`
+
+Immutable, ordered sequence.
+
+- Parentheses optional: `pt = 10, 20`
+- Supports unpacking: `x, y = pt`
+- Why immutable? Makes tuples hashable → usable as dict/set keys, guarantees fixed structure[^22][^23].
+  Typical roles: return multiple values, coordinates, config constants.
+
+## 7. Sets – `set`, `frozenset`
+
+Unordered collection of unique, hashable elements.
+
+```python
+tags = {"python", "ai", "flask"}
+if "ai" in tags: ...
+```
+
+- Operations: union `|`, intersection `&`, difference `-`, symmetric difference `^`[^13].
+- Mutable `set`; immutable `frozenset` for dictionary keys.
+  Use cases: membership testing, deduplication, relation algebra.
+
+## Picking the right type – real-world tips
+
+| Scenario                            | Best type                                      | Rationale                                |
+| :---------------------------------- | :--------------------------------------------- | :--------------------------------------- |
+| Logging unique visitor IDs          | `set`                                          | O(1) membership, duplicates auto-ignored |
+| JSON payload representing an object | `dict`                                         | Key–value mirrors JSON, order preserved  |
+| Constant RGB triplet                | `tuple`                                        | Fixed size, prevents accidental edits    |
+| Editable shopping cart items        | `list`                                         | Needs ordering and mutation              |
+| Switch/feature flags                | `bool` in a `dict`                             | Clear true/false semantics               |
+| Polynomial coefficients             | `list` or `tuple` depending on mutability need |                                          |
+
+## Cheat-sheet for mutability \& hashability
+
+| Type                          | Mutable? | Hashable? | Can be dict key? |
+| :---------------------------- | :------- | :-------- | :--------------- |
+| `int`, `float`, `complex`     | No       | Yes       | ✔               |
+| `str`                         | No       | Yes       | ✔               |
+| `bool`                        | No       | Yes       | ✔               |
+| `tuple` (all immutable items) | No       | Yes       | ✔               |
+| `list`                        | Yes      | No        | ✘                |
+| `dict`                        | Yes      | No        | ✘                |
+| `set`                         | Yes      | No        | ✘                |
+| `frozenset`                   | No       | Yes       | ✔               |
+
+## Takeaways
+
+1. Start with the high-level question “Will this collection change?”—that single answer often narrows the choice.
+2. Prefer immutables for safety and speed; fall back to mutables only when modification is required.
+3. Knowing the built-ins saves dependencies: many “utility” libraries duplicate what core types already provide.
+
+<div style="text-align: center">⁂</div>
+
+[^1]: https://www.tutorialsteacher.com/python/python-number-type
+
+[^2]: https://docs.python.org/3/library/stdtypes.html
+
+[^3]: https://www.simplilearn.com/tutorials/python-tutorial/float-in-python
+
+[^4]: https://www.geeksforgeeks.org/python/python-float-type-and-its-methods/
+
+[^5]: https://www.codesansar.com/python-programming/complex-data-type.htm
+
+[^6]: https://www.prepbytes.com/blog/python/complex-data-type-in-python/
+
+[^7]: https://www.w3schools.com/python/python_ref_string.asp
+
+[^8]: https://developers.google.com/edu/python/strings
+
+[^9]: https://www.pythonmorsels.com/string-methods/
+
+[^10]: https://www.pythonmorsels.com/truthiness/
+
+[^11]: https://www.uvm.edu/~cbcafier/cs1210/book/08_branching/truthiness_and_falsiness.html
+
+[^12]: https://www.geeksforgeeks.org/python/truthy-in-python/
+
+[^13]: https://www.pythoncheatsheet.org/blog/python-sets-what-why-how
+
+[^14]: https://www.pythoncheatsheet.org/blog/python-uv-package-manager
+
+[^15]: https://www.pythoncheatsheet.org/blog/python-projects-with-poetry-and-vscode-part-2
+
+[^16]: https://www.w3schools.com/python/python_lists.asp
+
+[^17]: https://docs.python.org/3/tutorial/datastructures.html
+
+[^18]: https://www.programiz.com/python-programming/list
+
+[^19]: https://www.geeksforgeeks.org/python/list-methods-python/
+
+[^20]: https://www.w3schools.com/python/python_ref_dictionary.asp
+
+[^21]: https://www.geeksforgeeks.org/python/python-dictionary-methods/
+
+[^22]: https://dev.to/iraycd/tuple-immutability-2038
+
+[^23]: https://www.geeksforgeeks.org/python/are-tuples-immutable-in-python/
+
+[^24]: https://www.w3schools.com/python/python_numbers.asp
+
+[^25]: https://realpython.com/python-data-types/
+
+[^26]: https://www.pytut.com/int/
+
+[^27]: https://jakevdp.github.io/PythonDataScienceHandbook/02.01-understanding-data-types.html
+
+[^28]: https://www.pythoncheatsheet.org/blog/python-3-14-breaking-free-from-gil
+
+[^29]: https://www.geeksforgeeks.org/python/python-string-methods/
+
+[^30]: https://docs.python.org/3/library/string.html
+
+[^31]: https://www.digitalocean.com/community/tutorials/python-string-functions
+
+[^32]: https://www.programiz.com/python-programming/methods/string
+
+[^33]: https://www.pythoncheatsheet.org/blog/python-easy-args-kwargs
+
+[^34]: https://www.pythoncheatsheet.org/blog/python-comprehensions-step-by-step
+
+[^35]: https://www.geeksforgeeks.org/python/python-lists/
+
+[^36]: https://www.linkedin.com/posts/brijpandeyji_i-created-this-fun-guide-to-python-list-operations-activity-7243582307918319616-VYv1
+
+[^37]: https://www.geeksforgeeks.org/python/python-data-types/
+
+[^38]: https://realpython.com/ref/builtin-types/float/
+
+[^39]: https://www.scaler.com/topics/complex-in-python/
+
+[^40]: https://realpython.com/ref/builtin-types/int/
+
+[^41]: https://www.pytut.com/float/
+
+[^42]: https://www.geeksforgeeks.org/python/python-complex-function/
+
+[^43]: https://discovery.cs.illinois.edu/guides/Python-Fundamentals/Python-data-types/
+
+[^44]: https://builtin.com/data-science/how-to-use-make-float-in-python
+
+[^45]: https://www.w3schools.com/python/ref_func_complex.asp
+
+[^46]: https://docs.python.org/3/library/functions.html
+
+[^47]: https://mathspp.com/blog/pydonts/truthy-falsy-and-bool
+
+[^48]: https://www.w3schools.com/python/python_strings.asp
+
+[^49]: https://stackoverflow.com/questions/49021823/understanding-the-truthiness-of-strings
+
+[^50]: https://developer.mozilla.org/en-US/docs/Learn_web_development/Core/Scripting/Useful_string_methods
+
+[^51]: https://www.freecodecamp.org/news/truthy-and-falsy-values-in-python/
+
+[^52]: https://www.thepythoncodingstack.com/p/telling-the-truthy-python-truthiness-falsiness
+
+[^53]: https://realpython.com/python-boolean/
+
+[^54]: https://www.learnpython.dev/02-introduction-to-python/090-boolean-logic/10-truthiness/
+
+[^55]: https://dev.to/icncsx/what-determines-the-truthiness-of-an-object-in-python-2e99
+
+[^56]: https://developers.google.com/edu/python/lists
+
+[^57]: https://dev.to/usooldatascience/a-quick-guide-to-python-dictionary-methods-with-examples-2gfb
+
+[^58]: http://inventwithpython.com/blog/python-tuples-are-immutable-except-when-theyre-mutable.html
+
+[^59]: https://www.w3schools.com/python/python_ref_list.asp
+
+[^60]: https://pages.di.unipi.it/marino/python/Dictionaries/Dictionarymethods.html
+
+[^61]: https://winterflower.github.io/2015/01/18/why-are-tuples-immutable/
+
+[^62]: https://www.programiz.com/python-programming/methods/dictionary
+
+[^63]: https://www.thepythoncodingstack.com/p/mutating-the-immutable-python-tuples
+
+[^64]: https://www.freecodecamp.org/news/python-dictionary-methods-dictionaries-in-python/
+
+[^65]: https://eng.libretexts.org/Bookshelves/Computer_Science/Programming_Languages/Making_Games_with_Python_and_Pygame_(Sweigart)/04:_Memory_Puzzle/4.12:_Tuples_vs._Lists,_Immutable_vs._Mutable