updated prompts on posts - formatting issues

Author: Sheikh-H

_posts/30DaysOfPython/2025-12-18-python-day6.md

@@ -34,8 +34,9 @@ var_b = tuple() # This also creates one using a function.
 
 I've explained that with tuples being immutable, we have many functions that we aren't able to do. So, for the latter part of this post I'll be writing functions that are used to access or check the information displayed within a tuple.
 
+<!-- prettier-ignore -->
 > Tip: You _can_ change a tuple to another collection data type like list, then modify it, and then change the new list with modified items in to a tuple.
-> {: .prompt-tip}
+{: .prompt-tip}
 
 ## Accessing Items in a Tuple
 
@@ -81,8 +82,9 @@ lst = ("Item1", "Item2", "Item3")
 print(lst[0:2:1]) # ["Item1", "Item2"]
 ```
 
+<!-- prettier-ignore -->
 > I've just realised that the method used to slice should really be referred to as [start:stop:step] not "skip" as it selects the data it lands on.
-> {: .prompt-tip}
+{: .prompt-tip}
 
 ## Changing Collection Data Types
 
@@ -114,8 +116,9 @@ lst2 = ("Item3", "Item4") + lst1 # Concatenating tuples
 print(lst2) # ("Item3", "Item4", "Item1", "Item2") # printed in the order it is inserted.
 ```
 
+<!-- prettier-ignore -->
 > **Tip**: I have also learnt that you can join different list types together but must first change or specify the list to being the type you require.
-> {: .prompt-tip}
+{: .prompt-tip}
 
 ```python
 lst1 = ["Item1"]

_posts/30DaysOfPython/2025-12-18-python-day7.md

@@ -30,8 +30,9 @@ Again, like with lists and tuples, you can create a set using initial values or
 lst = set()
 ```
 
+<!-- prettier-ignore -->
 > **Update**: Using `lst = {}` won't work as this creates a dictionary, not a set.
-> {: .prompt-warning}
+{: .prompt-warning}
 
 ## Accessing Items In a Set
 
@@ -166,8 +167,9 @@ print(lst1.difference(lst2)) # Kiwi
 print(lst1.symmetric_difference(lst2)) # {"Grapes", "Kiwi"}
 ```
 
+<!-- prettier-ignore -->
 > **Note**: `difference()` uses one set against another to compare, whereas `symmetric_difference()` uses both to compare and returns items that are unique in each set.
-> {: .prompt-tip}
+{: .prompt-tip}
 
 We can also use `isdisjoint()` to provide a boolean response to see if two sets contain similar items. If they do then we can't join them, if they don't we can.
 

_posts/30DaysOfPython/2025-12-18-python-day8.md

@@ -2,7 +2,7 @@
 layout: post
 title: Dictionaries - Storing Data Like a Database, Right In Python...
 description: >-
- While the title of this blog implies that a dictionary list in Python is a database, it's not. How it works, however, is very close to that of a database. Each entry stored has its own 'Key':'Value'. The key to each value is used to perform functions, replacing the need for indices. Here's what I've learnt about dictionaries on Day 8.
+  While the title of this blog implies that a dictionary list in Python is a database, it's not. How it works, however, is very close to that of a database. Each entry stored has its own 'Key':'Value'. The key to each value is used to perform functions, replacing the need for indices. Here's what I've learnt about dictionaries on Day 8.
 author: Sheikh Hussain
 date: 2025-12-26 17:00:00 +0000
 categories: [Python, Courses]
@@ -12,7 +12,6 @@ math: false
 mermaid: false
 image:
   path: 012026/python_day8.jpg
-  # lqip: data:image/...
   alt: Image from Pexels - Python Programming
 render_with_liquid: false
 media_subpath: /assets/img/posts/

_posts/30DaysOfPython/2025-12-20-python-day2.md

@@ -32,8 +32,9 @@ When creating a variable, we would use a principle to follow that helps create a
 
 By now we should have already gone over how to load a development environment on your device to start coding with Python.
 
+<!-- prettier-ignore -->
 > If you haven't yet installed both Python and VSCode, read this post: [Introduction To Python](https://sheikh-h.github.io/Blog/posts/python-day1/)
-> {: .prompt-info }
+{: .prompt-info }
 
 I'll use actual code examples to show you how you can;
 
@@ -62,13 +63,15 @@ Here is a comprehensive guideline to creating a Python Variable with the right n
 - **Can** be alpha-numeric (letters & numbers) and have underscores
 - Should represent or be named something **relative** to the **information stored**.
 
+<!-- prettier-ignore -->
 > Valid uses:
 
 - num_1
 - Num_1
 - nuM_1
   {: .prompt-tip }
 
+<!-- prettier-ignore -->
 > Invalid uses:
 
 - 1_num
@@ -80,8 +83,9 @@ The naming convention we've used here is recognised as 'snake case'. This is the
 
 Another convention we _could_ use is called 'Camel Case', where we would capitalise the first character of each word and join them using underscores like `Camel_Case`.
 
+<!-- prettier-ignore -->
 > **Note**: When it comes to creating variables, always keep in mind of the _built-in_ functions we have access to in Python as these also use 'reserved' words. It just means that using an existing functions name as a variable could cause errors throughout your program. Try be as unique as possible for all variable names.
-> {: .prompt-warning}
+{: .prompt-warning}
 
 ## Performing Functions
 
@@ -168,8 +172,9 @@ print(is_light_on)
 - **Lists**
   - Lists are exactly as described, they are a list of data types that you can store. There are 4 collection types that you can have; Lists, Sets, Tuples, and Dictionaries. We'll be learning about lists, I believe on **Day 5**.
 
+<!-- prettier-ignore -->
 > A concept called **List Comprehension** is explained in **Day 13** of the course I am using, which will further dissect the lists topic/module.
-> {: .prompt-tip}
+{: .prompt-tip}
 
 ## Using Different Data Types
 
@@ -222,8 +227,9 @@ address = {
 
 ```
 
+<!-- prettier-ignore -->
 > You can go on ahead and do the same on your own Python script and play around with some of the data types. Try making your own or use different data types for each!
-> {: .prompt-tip}
+{: .prompt-tip}
 
 Let's now go on ahead and start using a function with these variables we have created. The function we will use is `type()` which brings back the data type of the information stored in that variable.
 
@@ -264,8 +270,9 @@ Similar to primitive data types, Python has a large library of built-in function
 
 By this point, I would say it's not imperative that we learn all the functions there are. However, it's a good idea to get a feel of what we have access to and what some of them do.
 
+<!-- prettier-ignore -->
 > Visit 👉 [Python's Builtin Functions Documentation](https://docs.python.org/3.9/library/functions.html) to get a list of all the functions
-> {: .prompt-tip}
+{: .prompt-tip}
 
 ![Python built-in functions overview](012026/builtin-functions.png)
 _Image source: [30 Days Of Python: Day 2](https://github.com/Asabeneh/30-Days-Of-Python/blob/master/02_Day_Variables_builtin_functions/02_variables_builtin_functions.md)_

_posts/30DaysOfPython/2025-12-21-python-day3.md

@@ -185,8 +185,9 @@ From that example, we are able to see how we can create conditions using IF Stat
 
 While reviewing the course content and external sources, I came across operator types that weren’t heavily emphasised in the exercises. Even though they’re more niche, I wanted to include them here so my notes stay complete[^f2].
 
+<!-- prettier-ignore -->
 > This is a complete guide to use or resource I would read over - [Python Identity Operators](https://www.w3schools.com/python/python_operators.asp)
-> {: .prompt-tip}
+{: .prompt-tip}
 
 ### Bitwise (Binary) Assignment Operators
 
@@ -275,8 +276,9 @@ print(x is y) # False
 print(x == y) # True
 ```
 
+<!-- prettier-ignore -->
 > **Update**: I have recently learnt about **constant** and **runtime** sequences which explain that any sequential data, like strings, created _before_ runtime get stored in the same memory location for as long as the data inside are identical. Therefore, if you where to use the identity operator on these variables it would bring back a `True` statement.
-> {: .prompt-tip}
+{: .prompt-tip}
 
 _Example:_
 

_posts/30DaysOfPython/2025-12-21-python-day4.md

@@ -51,8 +51,9 @@ of code'''
 
 Before I begin here, I would like to add that there are many built-in functions that Python has and I have discussed this in one of my earlier posts - _[Variables, Built-in Functions, and Data Types in Python](https://sheikh-h.github.io/Blog/posts/python-day2/)_.
 
+<!-- prettier-ignore -->
 > Here is the official link from Python for built-in functions [Python Documentation - Built-In Functions](https://docs.python.org/3/library/functions.html)!
-> {: .prompt-tip}
+{: .prompt-tip}
 
 ```python
 var_a = "My name is Sheikh Hussain"
@@ -82,8 +83,9 @@ print(full_name)
 
 Remember:
 
+<!-- prettier-ignore -->
 > Using the `+` doesn't _add_ strings together, it creates a new string and presents that to you. The original variable stays the same.
-> {: .prompt-tip}
+{: .prompt-tip}
 
 ---
 
@@ -125,8 +127,9 @@ There are several different types of escape functions that we can use and here i
 | `\uXXXX`        | Unicode (16-bit)                        | `print("\u03A9")`             | Ω                           |
 | `\UXXXXXXXX`    | Unicode (32-bit)                        | `print("\U0001F600")`         | 😀                          |
 
+<!-- prettier-ignore -->
 > This is a comprehensive list created with AI, I would say only 1/3 of them you'll want to really use. - It's just good to know.
-> {: .prompt-info}
+{: .prompt-info}
 
 ---
 
@@ -249,8 +252,9 @@ print(word[-1]) # g
 
 You can access items either using positive or negative numbers.
 
+<!-- prettier-ignore -->
 > Positive numbers will start from `0` and work to the last item in the variable, negative numbers will start at `-1` then work towards the beginning of the variable.
-> {: .prompt-tip}
+{: .prompt-tip}
 
 ---
 
@@ -282,8 +286,9 @@ Using this notation, you can select a portion of a sequence (like a string or li
 
 - Step/Skip tells Python how many items to skip each time and select the index it lands on
 
+<!-- prettier-ignore -->
 > **Tip**: If you leave start or stop empty, Python will automatically use the beginning or end of the sequence.
-> {: .prompt-tip}
+{: .prompt-tip}
 
 ---
 

_posts/30DaysOfPython/2025-12-21-python-day5.md

@@ -42,8 +42,9 @@ Here is a small table with the different list types I have learnt so far:
 | Set        | Unordered, un-indexed, and mutable     | `items = {"Item1", 5, 12.33, False}`    |
 | Dictionary | Ordered (Python 3.7+), key-value pairs | `items = {"name": "Item1", "count": 5}` |
 
+<!-- prettier-ignore -->
 > **Note**: When we use the term _ordered_ for lists, we mean _preserving_ the order in which items were inserted - **not logical ordering**. Lists, Tuples, and Dictionaries **preserve** insertion order. In contrast, _Sets_ are unordered, hence if you were to create a set with items in, with each run of the program, you could see the items shift.
-> {: .prompt-tip}
+{: .prompt-tip}
 
 ## Creating lists
 
@@ -99,8 +100,9 @@ new_lst = lst + ["Item8"]
 print(new_lst) # ["Item2", "Item1", "Item3", "Item4", "Item5", "Item6", "Item7", "Item8"]
 ```
 
+<!-- prettier-ignore -->
 > **List Concatenation** is an operation that produces a _new list_ by combining the items from other lists.
-> {: .prompt-tip}
+{: .prompt-tip}
 
 We can also use advanced functions like `for loops` to add items into a list using a loop function, with each iteration of the loop an item from a list gets added.
 
@@ -247,8 +249,9 @@ print("Cat" in lst) # True
 print("Lion" in lst) # False
 ```
 
+<!-- prettier-ignore -->
 > I want to recall a construct that I mentioned before while discussing operators, _constant and runtime sequences_[^f3]. Lists, though sequential, are mutable and therefore identical lists do not get stored in the same location.
-> {: .prompt-tip}
+{: .prompt-tip}
 
 ## Finding The Index Of An Item
 
@@ -280,8 +283,9 @@ print(d) # ["Item4", "Item5"]
 
 The `*variable =` assignment operator produces a new list with the _rest_ of the items in the list you specify.
 
+<!-- prettier-ignore -->
 > **Hint**: With extended iterable unpacking, you can assign some items to individual variables and use a starred variable (\*variable) to collect the remaining items. You can place the starred variable at the start, middle, or end, but you can only have one starred variable.
-> {: .prompt-tip}
+{: .prompt-tip}
 
 ## Copying Lists
 
@@ -342,8 +346,9 @@ lst.reverse()
 print(lst) # ["Item 3", "Item 1", "Item 2"]
 ```
 
-> Note how this just printed it all out in reverse rather than ordering.
-> {: .prompt-info}
+<!-- prettier-ignore -->
+> **Note**: how this just printed it all out in reverse rather than ordering.
+{: .prompt-info}
 
 ## Counting Items In a List