[Edit] Python Built-in Functions: sorted() (#7401)

* [Edit] Python Built-in Functions: sorted()

* minor fixes and changed one faq based on PAA

---------

Author: Sriparno08

content/python/concepts/built-in-functions/terms/sorted/sorted.md

@@ -1,140 +1,96 @@
 ---
 Title: 'sorted()'
-Description: 'Takes in an iterator object, such as a list, tuple, dictionary, set, or string, and sorts it according to a parameter.'
+Description: 'Returns a new sorted list from the elements of any iterable, without modifying the original.'
 Subjects:
-  - 'Data Science'
   - 'Computer Science'
+  - 'Data Science'
 Tags:
-  - 'Strings'
   - 'Functions'
   - 'Iterators'
   - 'Lists'
+  - 'Strings'
 CatalogContent:
   - 'learn-python-3'
   - 'paths/analyze-data-with-python'
 ---
 
-Takes in an iterator object, such as a list, tuple, dictionary, set, or string, and sorts it according to a parameter.
+Python's **`sorted()`** [function](https://www.codecademy.com/resources/docs/python/functions) takes in an [iterable](https://www.codecademy.com/resources/docs/python/iterators) object, such as a [list](https://www.codecademy.com/resources/docs/python/lists), [tuple](https://www.codecademy.com/resources/docs/python/tuples), [dictionary](https://www.codecademy.com/resources/docs/python/dictionaries), [set](https://www.codecademy.com/resources/docs/python/sets), or [string](https://www.codecademy.com/resources/docs/python/strings), and sorts it according to a parameter. This function is versatile, easy to use, and supports custom sorting logic using optional parameters.
 
-## Syntax
+## Python `sorted()` Syntax
 
 ```pseudo
 sorted(iterable, key=None, reverse=False)
 ```
 
-The `key` and `reverse` parameters are optional, and will default to `None` and `False`. `False` sorts ascending, and `True` descending. The `key` takes an input function to determine the comparison key.
+**Parameters:**
 
-## Example 1
+- `iterable`: The sequence (list, tuple, string, dictionary, etc.) to be sorted.
+- `key` (Optional): A function that acts as a sorting key.
+- `reverse` (Optional): If `True`, the result is sorted in descending order.
 
-`sorted()` can be used on either numbers or letters, but not on a combination of the two:
+**Return value:**
 
-```python
-my_list = ["beta", "epsilon", "alpha", "delta", "gamma"]
+Returns a list that includes the elements in the iterable in sorted order.
 
-new_list = sorted(my_list)
+## Example 1: Sorting a List Using `sorted()` Function in Python
 
-print(new_list)
-# Output: ['alpha', 'beta', 'delta', 'epsilon', 'gamma']
-```
+This example uses `sorted()` to sort the `my_list` list:
 
-```python
-my_list = [7,2,3,5,1,4,6]
+```py
+my_list = ["beta", "epsilon", "alpha", "delta", "gamma"]
 
 new_list = sorted(my_list)
 
 print(new_list)
-# Output: [1, 2, 3, 4, 5, 6, 7]
 ```
 
-## Example 2
-
-Changing the `reverse` parameter changes the order of the sort:
+Here is the output:
 
-```python
-my_list = [7,2,3,5,1,4,6]
-
-new_list = sorted(my_list, reverse=True)
-
-print(new_list)
-# Output: [7, 6, 5, 4, 3, 2, 1]
+```shell
+['alpha', 'beta', 'delta', 'epsilon', 'gamma']
 ```
 
-## Example 3
-
-When `reversed` is `False`, `sorted()` will sort numbers from low to high, and letters alphabetically. However, capital letters will come before lowercase letters. In order to sort all objects with the same key, use a function with the key `parameter`:
+## Example 2: Sorting in Descending Order Using `sorted()`
 
-```python
-my_string = "bCEad"
+This example uses `sorted()` with the `reverse` parameter set to `True` to sort the `my_list` list in descending order:
 
-after_sorted = sorted(my_string)
+```py
+my_list = [7, 2, 3, 5, 1, 4, 6]
 
-print(after_sorted)
-# Output: ['C', 'E', 'a', 'b', 'd']
-
-after_sorted = sorted(my_string, key=str.lower)
+new_list = sorted(my_list, reverse=True)
 
-print(after_sorted)
-# Output: ['a', 'b', 'C', 'd', 'E']
+print(new_list)
 ```
 
-## Example 4
-
-The `key` parameter can also be used to sort by other comparisons, such as length:
-
-```python
-my_list = ["aaa", "bb", "c"]
-
-my_sorted_list = sorted(my_list)
-
-print(my_sorted_list)
-# Output: ['aaa', 'bb', 'c']
+Here is the output:
 
-my_sorted_list = sorted(my_list, key=len)
-
-print(my_sorted_list)
-# Output: ['c', 'bb', 'aaa']
+```shell
+[7, 6, 5, 4, 3, 2, 1]
 ```
 
-## Example 5
-
-The `key` parameter can even take in custom functions:
-
-```python
-def sorting_func(i):
-  return i - i**2
-
-my_list = [2,1,4,3]
+## Codebyte Example: Using Python's `sorted()` with a Key
 
-my_sorted_list = sorted(my_list)
+This codebyte example uses `sorted()` with the `key` parameter set to `len` to sort the `words` list based on the length of its items:
 
-print(my_sorted_list)
-# Output: [1, 2, 3, 4]
+```codebyte/python
+words = ["banana", "apple", "cherry", "date"]
 
-my_sorted_list = sorted(my_list, key=sorting_func)
+sorted_words = sorted(words, key=len)
 
-print(my_sorted_list)
-# Output: [4, 3, 2, 1]
+print(sorted_words)
 ```
 
-## Codebyte Example
+## Frequently Asked Questions
 
-Sorting a list of dictionaries based on a specific key:
+### 1. What is the difference between `sorted()` and `list.sort()`?
 
-```codebyte/python
-my_list_of_dicts = [
-    {"name": "Alice", "age": 30},
-    {"name": "Bob", "age": 25},
-    {"name": "Charlie", "age": 35},
-    {"name": "David", "age": 28}
-]
+- `sorted()` works on any iterable and returns a new sorted list.
+- `list.sort()` modifies the list in-place and returns `None`.
 
-# Sort the list of dictionaries based on the "age" key in ascending order
-sorted_list = sorted(my_list_of_dicts, key=lambda x: x["age"])
+### 2. Can I sort in descending order using `sorted()`?
 
-print(sorted_list)
+Yes, you can set the `reverse` parameter in `sorted()` to `True` to sort in descending order.
 
-# Sort the list of dictionaries based on the "name" key in alphabetical order (case-insensitive)
-sorted_list_by_name = sorted(my_list_of_dicts, key=lambda x: x["name"].lower())
+### 3. Does `sorted()` always return a list?
 
-print(sorted_list_by_name)
-```
+Yes, no matter what iterable you pass in—whether it’s a string, tuple, set, or dictionary, `sorted()` always returns a new list containing the sorted elements. It never returns the same type as the input.