Enhance documentation for built-in functions

- Updated examples and explanations for the following built-in functions:
  - bin()
  - complex()
  - delattr()
  - dict()
  - divmod()
  - globals()
  - hasattr()
  - hash()
  - id()
  - __import__()
  - isinstance()
  - iter()
  - locals()
  - max()
  - memoryview()
  - min()
  - next()
  - object()
  - oct()
  - ord()
  - pow()
  - property()
  - repr()
  - reversed()
  - round()
  - set()
  - setattr()
  - sorted()
  - sum()
  - super()
  - tuple()
  - vars()
  - zip()
- Added new examples and clarified usage for better understanding.

Author: Carlos

.gitignore

@@ -23,3 +23,4 @@ dist-ssr
 .vite-ssg-temp
 coverage
 .env
+.github/prompts/custom.prompt.md

docs/builtin/bin.md

@@ -16,22 +16,20 @@ Python bin() built-in function
   </base-disclaimer-content>
 </base-disclaimer>
 
-## Examples
+The `bin()` function converts an integer into its binary representation. The resulting string is prefixed with "0b" to indicate that it's a binary number.
 
-```python
->>> bin(1)
-# '0b1'
-
->>> bin(10)
-# '0b1010'
+### Examples
 
->>> bin(100)
-# '0b1100100'
+Here are a few examples of how to use `bin()`:
 
->>> bin(1000)
-# '0b1111101000'
+```python
+# Convert integers to binary
+print(bin(2))    # Output: 0b10
+print(bin(7))    # Output: 0b111
+
+# The original examples
+print(bin(1))    # Output: 0b1
+print(bin(10))   # Output: 0b1010
+print(bin(100))  # Output: 0b1100100
+print(bin(1000)) # Output: 0b1111101000
 ```
-
-<!-- remove this tag to start editing this page -->
-<empty-section />
-<!-- remove this tag to start editing this page -->

docs/builtin/complex.md

@@ -16,7 +16,24 @@ Python complex() built-in function
   </base-disclaimer-content>
 </base-disclaimer>
 
-## Examples
+The `complex()` function creates a complex number. It can take a real and an imaginary part as arguments. If only one argument is provided, it's considered the real part, and the imaginary part is zero.
+
+### Examples
+
+**Creating complex numbers:**
+
+```python
+# With real and imaginary parts
+print(complex(3, 4))  # Output: (3+4j)
+
+# With only a real part
+print(complex(5))     # Output: (5+0j)
+
+# From a string
+print(complex("2+3j")) # Output: (2+3j)
+```
+
+Here is the original example:
 
 ```python
 >>> complex(1)
@@ -28,7 +45,3 @@ Python complex() built-in function
 >>> complex('100')
 # (100+0j)
 ```
-
-<!-- remove this tag to start editing this page -->
-<empty-section />
-<!-- remove this tag to start editing this page -->

docs/builtin/delattr.md

@@ -16,29 +16,37 @@ Python delattr() built-in function
   </base-disclaimer-content>
 </base-disclaimer>
 
+The `delattr()` function is used to delete an attribute from an object. It takes two arguments: the object and the name of the attribute to delete (as a string). It's the counterpart to `setattr()`.
+
+### Examples
+
+**Deleting an attribute from an object:**
+
 ```python
 class Person:
     def __init__(self, name, age):
         self.name = name
         self.age = age
 
->>> person = Person("John", 30)
->>> delattr(person, 'age')
->>> person.__dict__
-# {'name': 'John'}
+person = Person("John", 30)
+print(person.__dict__)  # Output: {'name': 'John', 'age': 30}
 
+delattr(person, 'age')
+print(person.__dict__)  # Output: {'name': 'John'}
+```
+
+**Trying to delete a non-existent attribute:**
+
+```python
 class Car:
     def __init__(self, make, model):
         self.make = make
         self.model = model
 
->>> car = Car("Toyota", "Corolla")
->>> try:
-...     delattr(car, 'year')
-... except AttributeError as e:
-...     print(f"Error: {e}")
+car = Car("Toyota", "Corolla")
+try:
+    delattr(car, 'year')
+except AttributeError as e:
+    print(f"Error: {e}")
 # Error: 'Car' object has no attribute 'year'
 ```
-<!-- remove this tag to start editing this page -->
-<empty-section />
-<!-- remove this tag to start editing this page -->

docs/builtin/dict.md

@@ -16,14 +16,38 @@ Python dict() built-in function
   </base-disclaimer-content>
 </base-disclaimer>
 
-## Examples
+The `dict()` constructor creates a new dictionary. A dictionary is a collection of key-value pairs.
+
+You can create an empty dictionary, or create a dictionary from keyword arguments or from an iterable of key-value pairs.
+
+### Examples
+
+**Create an empty dictionary:**
+
+```python
+my_dict = dict()
+print(my_dict)  # Output: {}
+```
+
+**Create a dictionary with keyword arguments:**
+
+```python
+my_dict = dict(name="John", age=30)
+print(my_dict)  # Output: {'name': 'John', 'age': 30}
+```
+
+**Create a dictionary from a list of tuples:**
+
+```python
+my_list = [('name', 'Jane'), ('age', 25)]
+my_dict = dict(my_list)
+print(my_dict)  # Output: {'name': 'Jane', 'age': 25}
+```
+
+
 
 ```python
 >>> a = dict()
 >>> type(a)
 # <class 'dict'>
 ```
-
-<!-- remove this tag to start editing this page -->
-<empty-section />
-<!-- remove this tag to start editing this page -->

docs/builtin/divmod.md

@@ -16,17 +16,18 @@ Python divmod() built-in function
   </base-disclaimer-content>
 </base-disclaimer>
 
-## Examples
+The `divmod()` function takes two numbers as arguments and returns a tuple containing the quotient and the remainder of their integer division. It's a convenient way to get both results in a single call.
+
+### Examples
 
 ```python
->>> divmod(2, 2)
-# (1, 0)
->>> divmod(10, 2)
-# (5, 0)
->>> divmod(7, 2)
-# (3, 1)
-```
+# Get quotient and remainder
+quotient, remainder = divmod(10, 3)
+print(quotient)   # Output: 3
+print(remainder)  # Output: 1
 
-<!-- remove this tag to start editing this page -->
-<empty-section />
-<!-- remove this tag to start editing this page -->
+# Original examples
+print(divmod(2, 2))   # Output: (1, 0)
+print(divmod(10, 2))  # Output: (5, 0)
+print(divmod(7, 2))   # Output: (3, 1)
+```

docs/builtin/globals.md

@@ -16,6 +16,34 @@ Python globals() built-in function
   </base-disclaimer-content>
 </base-disclaimer>
 
-<!-- remove this tag to start editing this page -->
-<empty-section />
-<!-- remove this tag to start editing this page -->
+The `globals()` function in Python returns a dictionary representing the current global symbol table. This includes all global variables, functions, and other objects in the current scope.
+
+It can be useful for inspecting the global namespace or for dynamically accessing global variables by their string names.
+
+### Examples
+
+```python
+# Define a global variable
+global_var = "I am global"
+
+def my_function():
+    # Access global variables using globals()
+    global_dict = globals()
+    print(global_dict["global_var"])  # Output: I am global
+
+    # Modify a global variable
+    global_dict["global_var"] = "Modified global"
+
+my_function()
+print(global_var)  # Output: Modified global
+```
+
+You can also use `globals()` to create new global variables from within a function:
+
+```python
+def create_global():
+    globals()["new_global"] = "This was created dynamically"
+
+create_global()
+print(new_global)  # Output: This was created dynamically
+```

docs/builtin/hasattr.md

@@ -16,6 +16,18 @@ Python hasattr() built-in function
   </base-disclaimer-content>
 </base-disclaimer>
 
-<!-- remove this tag to start editing this page -->
-<empty-section />
-<!-- remove this tag to start editing this page -->
+The `hasattr()` function checks if an object has a given attribute. It takes the object and the attribute name (as a string) as arguments and returns `True` if the attribute exists, and `False` otherwise.
+
+### Example
+
+```python
+class Person:
+    name = "John"
+    age = 30
+
+p = Person()
+
+print(hasattr(p, 'name'))  # Output: True
+print(hasattr(p, 'age'))   # Output: True
+print(hasattr(p, 'email')) # Output: False
+```

docs/builtin/hash.md

@@ -16,17 +16,27 @@ Python hash() built-in function
   </base-disclaimer-content>
 </base-disclaimer>
 
-## Examples
+The `hash()` function returns an integer representing the hash value of an object. This is primarily used by dictionaries to quickly look up keys.
+
+Only "hashable" objects can be passed to `hash()`. An object is hashable if it has a hash value that never changes during its lifetime. All of Python's built-in immutable types (like strings, numbers, and tuples) are hashable, while mutable containers (like lists and dictionaries) are not.
+
+### Examples
 
 ```python
->>> hash(1)
-# 1
->>> hash('1')
-# -3658718886659147670
->>> hash('10')
-# 5216539490891759533
-```
+# Hash of an integer is the integer itself
+print(hash(1))      # Output: 1
+print(hash(1.0))    # Output: 1 (1 and 1.0 are equal)
 
-<!-- remove this tag to start editing this page -->
-<empty-section />
-<!-- remove this tag to start editing this page -->
+# Hash of a string (output varies)
+print(hash('hello'))
+
+# Hash of a tuple (output varies)
+print(hash((1, 2, 3)))
+
+# Trying to hash a list will raise a TypeError
+try:
+    hash([1, 2, 3])
+except TypeError as e:
+    print(e)
+# Output: unhashable type: 'list'
+```

docs/builtin/id.md

@@ -16,17 +16,21 @@ Python id() built-in function
   </base-disclaimer-content>
 </base-disclaimer>
 
-## Examples
+The `id()` function returns a unique integer that identifies an object in memory. This ID is guaranteed to be unique for the lifetime of the object. It's essentially the memory address of the object.
+
+### Examples
 
 ```python
->>> id(1)
-# 9788960
->>> id('1')
-# 140269689726000
->>> id([1, 2])
-# 140269672924928
-```
+x = 10
+y = 10
+z = 20
 
-<!-- remove this tag to start editing this page -->
-<empty-section />
-<!-- remove this tag to start editing this page -->
+print(id(x))  # Output might be something like 4331368528
+print(id(y))  # Output will be the same as id(x) because Python caches small integers
+print(id(z))  # Output will be different
+
+# Original examples
+print(id(1))
+print(id('1'))
+print(id([1, 2]))
+```