[Term Entry - Edit]: Python namedtuple (#7551)

* [Term Entry - Edit]: Python `namedtuple`

* Update namedtuple.md

* Update content/python/concepts/collections-module/terms/namedtuple/namedtuple.md

* Update content/python/concepts/collections-module/terms/namedtuple/namedtuple.md

* Update content/python/concepts/collections-module/terms/namedtuple/namedtuple.md

* Update content/python/concepts/collections-module/terms/namedtuple/namedtuple.md

---------

Author: mamtawardhani

content/python/concepts/collections-module/terms/namedtuple/namedtuple.md

@@ -1,79 +1,192 @@
 ---
 Title: 'namedtuple'
-Description: 'A tuple subclass with named fields'
+Description: 'Creates tuple subclasses with named fields for improved code readability in Python namedtuple structures.'
 Subjects:
   - 'Computer Science'
   - 'Data Science'
 Tags:
+  - 'Collections'
+  - 'Data Structures'
   - 'Tuples'
-  - 'Data Types'
 CatalogContent:
   - 'learn-python-3'
   - 'paths/computer-science'
 ---
 
-A **namedtuple** is a data type in the `collections` module. It is a [`tuple`](https://www.codecademy.com/resources/docs/python/tuples) subclass that allows you to create immutable objects with named fields. This improves code readability by providing meaningful names for each element and making the code more explicit.
+A **`namedtuple`** is a factory function in Python's `collections` module that creates [`tuple`](https://www.codecademy.com/resources/docs/python/tuples) subclasses with named fields. It provides an immutable data structure that allows access to elements through descriptive field names instead of numeric indices, making Python `namedtuple` structures more readable and self-documenting while maintaining the memory efficiency and performance characteristics of regular tuples.
 
 ## Syntax
 
 ```pseudo
-namedtuple(typename, field_names)
+namedtuple(typename, field_names, *, rename=False, defaults=None, module=None)
 ```
 
-- `typename`: The name of the new tuple subclass.
-- `field_names`: It represents the names of the fields in the named tuple.
+**Parameters:**
 
-## Additional Methods
+- `typename`: A string specifying the name of the new tuple subclass
+- `field_names`: A sequence of strings or a single string with field names separated by whitespace and/or commas
+- `rename`: If `True`, invalid field names are automatically replaced with positional names
+- `defaults`: An iterable of default values for the rightmost parameters
+- `module`: Value for the `__module__` field
 
-There are 3 specific `namedtuple` methods in addition to the standard methods inherited from tuples. All methods begin with an underscore to avoid conflicts with field names.
+**Return value:**
 
--`._make(iterable)`: (Class method) Creates a new instance based on an existing sequence or iterable.
+A new tuple subclass with named fields that can be accessed via dot notation.
 
--`._asdict()`: Returns a [`dict`](https://www.codecademy.com/resources/docs/python/dictionaries) with matching field names and values.
+## Example 1: Python `namedtuple` Basic Example
 
--`._replace(kwarg)`: Returns a new instance with fields replaced by the value provided as a keyword argument.
+This example demonstrates how to create a Python `namedtuple`, access its elements, and perform basic operations in Python:
 
-There are 2 specific attributes `._fields` and `_field_defaults` that will allow you respectively to list field names and to return a [`dict`](https://www.codecademy.com/resources/docs/python/dictionaries) with field names related to their default values.
+```py
+from collections import namedtuple
+
+# Create a namedtuple
+Person = namedtuple('Person', ['name', 'age', 'city'])
+
+# Create instances
+john = Person('John Doe', 30, 'New York')
+jane = Person(name='Jane Smith', age=25, city='Boston')
+
+print(john)
+print(jane)
+
+# Access Operations
+print("Access by field name:", john.name)
+print("Access by index:", john[0])
+print("Access using getattr:", getattr(john, 'age'))
+
+# Conversion Operations
+print("Convert to dict:", john._asdict())
+
+# Additional Operations
+print("Field names:", Person._fields)
+new_person = john._replace(age=31)
+print("After replace:", new_person)
+```
+
+This example results in the following output:
+
+```shell
+Person(name='John Doe', age=30, city='New York')
+Person(name='Jane Smith', age=25, city='Boston')
+Access by field name: John Doe
+Access by index: John Doe
+Access using getattr: 30
+Convert to dict: OrderedDict([('name', 'John Doe'), ('age', 30), ('city', 'New York')])
+Field names: ('name', 'age', 'city')
+After replace: Person(name='John Doe', age=31, city='New York')
+```
+
+## Conversion Operations
+
+`namedtuple` provides several useful methods to convert between different data types and create new instances from existing data. These conversion operations make it easy to work with `namedtuples` alongside other Python data structures like lists, dictionaries, and iterables. There are three main conversion operations available:
+
+- Using `_make()`: Creates `namedtuple` instances from iterables
+- Using `_asdict()`: Converts namedtuples to ordered dictionaries
+- Using `**` operator: Creates namedtuples from dictionaries using unpacking
+
+Let's examine each conversion operation.
+
+### Example 2: Using Named Tuples Python `_make()` Method
+
+Creates a `namedtuple` instance from an existing iterable, making it easy to convert lists, tuples, or other sequences into namedtuples:
+
+```py
+from collections import namedtuple
+
+# Create namedtuple class
+Coordinate = namedtuple('Coordinate', ['x', 'y', 'z'])
 
-## Example
+# Create from different iterables
+point_list = [10, 20, 30]
+point_tuple = (5, 15, 25)
 
-In the following example, a `namedtuple` `codecademyStudent` with two fields (`username` and `courses`) to create two student instances is created. Two sentences will then be displayed about each student and their attributes.
+# Use _make() to create instances
+coord1 = Coordinate._make(point_list)
+coord2 = Coordinate._make(point_tuple)
+
+print(coord1)
+print(coord2)
+```
+
+This example results in the following output:
+
+```shell
+Coordinate(x=10, y=20, z=30)
+Coordinate(x=5, y=15, z=25)
+```
+
+### Example 3: Python Namedtuple `_asdict()` Method
+
+Converts a `namedtuple` instance to an OrderedDict, preserving the field names as keys and their corresponding values:
 
 ```py
 from collections import namedtuple
 
-codecademyStudent = namedtuple('codecademyStudent', ['username', 'courses'])
+# Create namedtuple
+Student = namedtuple('Student', ['name', 'grade', 'subject'])
+student = Student('Alice Johnson', 95, 'Mathematics')
 
-student1 = codecademyStudent(username='Foo', courses=['Python', 'Computer Science'])
-student2 = codecademyStudent(username='Bar', courses=['Javascript', 'Web Development'])
+# Convert to dictionary
+student_dict = student._asdict()
+print("As dictionary:", student_dict)
 
-print("Student 1:", "Username:", student1.username, "| Courses involvement:", student1.courses)
-print("Student 2:", "Username:", student2.username, "| Courses involvement:", student2.courses)
+# Access dictionary values
+print("Name from dict:", student_dict['name'])
+print("Grade from dict:", student_dict['grade'])
 ```
 
-The above example results in the following output:
+This example results in the following output:
 
 ```shell
-Student 1: Username: Foo | Courses involvement: ['Python', 'Computer Science']
-Student 2: Username: Bar | Courses involvement: ['Javascript', 'Web Development']
+As dictionary: OrderedDict([('name', 'Alice Johnson'), ('grade', 95), ('subject', 'Mathematics')])
+Name from dict: Alice Johnson
+Grade from dict: 95
 ```
 
-## Codebyte Example
+### Example 4: Namedtuple Using `**` (Double Star) Operator
 
-The following example creates a `namedtuple` instance from an iterable, then changes one of its assigned values, and returns a [`dict`](https://www.codecademy.com/resources/docs/python/dictionaries) with the default preset values.
+Unpacks a dictionary or `namedtuple` to create new `namedtuple` instances using keyword arguments:
 
-```codebyte/python
+```py
 from collections import namedtuple
 
-numbers = [0, 1, 2]
-myNamedTuple = namedtuple('myNamedTuple', ['a', 'b', 'c'])
-myNamedTuple_numbers = myNamedTuple._make(numbers)
-
-print(myNamedTuple_numbers._fields)
-print("---")
-print(myNamedTuple_numbers)
-print(myNamedTuple_numbers.c)
-print(myNamedTuple_numbers._asdict())
-print("---")
-print(myNamedTuple_numbers._replace(c=3))
+# Create namedtuple class
+Product = namedtuple('Product', ['name', 'price', 'category'])
+
+# Create from dictionary using ** operator
+product_data = {
+    'name': 'Laptop',
+    'price': 999.99,
+    'category': 'Electronics'
+}
+
+laptop = Product(**product_data)
+print("Created from dict:", laptop)
+
+# Create from existing namedtuple using _replace (cleanest way)
+existing_product = Product('Phone', 599.99, 'Electronics')
+modified_product = existing_product._replace(price=549.99)
+print("Modified product:", modified_product)
 ```
+
+This example results in the following output:
+
+```shell
+Created from dict: Product(name='Laptop', price=999.99, category='Electronics')
+Modified product: Product(name='Phone', price=549.99, category='Electronics')
+```
+
+## Frequently Asked Questions
+
+### 1. What is a `namedtuple` in Python?
+
+A `namedtuple` is a factory function in the `collections` module that creates tuple subclasses with named fields. It combines the immutability and memory efficiency of tuples with the readability of accessing elements by name rather than index.
+
+### 2. How do you create a `namedtuple` in Python?
+
+You create a `namedtuple` by calling `namedtuple(typename, field_names)` where `typename` is the class name and `field_names` is a list of field names. For example: `Person = namedtuple('Person', ['name', 'age'])`.
+
+### 3. What are the 4 collection data types in Python?
+
+The four main built-in collection data types in Python are: list (ordered and mutable), tuple (ordered and immutable), set (unordered and mutable with unique elements), and dict (ordered key-value pairs, mutable). The `collections` module provides additional specialized data types like `namedtuple`, `deque`, `Counter`, and `defaultdict`.