Of course! The term "list template" in Python can mean a few different things depending on the context. Here’s a comprehensive guide covering the most common interpretations, from simple to advanced.

The Simplest "Template": A List of Placeholder Strings

This is the most literal interpretation. You have a list where you want to fill in some values later.

# A list of strings with placeholders
template_list = [
    "Hello, {name}!",
    "Your order {order_id} has been processed.",
    "Your balance is ${balance:.2f}."
]
# The data to fill in the template
data = {
    "name": "Alice",
    "order_id": "12345",
    "balance": 99.95
}
# Fill in the template using a list comprehension
filled_list = [s.format(**data) for s in template_list]
# Print the result
for item in filled_list:
    print(item)

Output:

Hello, Alice!
Your order 12345 has been processed.
Your balance is $99.95.

How it works:

• template_list is your list of "templates".
• data is a dictionary containing the values for the placeholders ({name}, {order_id}, etc.).
• s.format(**data) unpacks the data dictionary into keyword arguments for the format() method. This is a clean and Pythonic way to fill the placeholders.

Advanced Templating: Using the string.Template Class

For more complex or user-generated templates, Python's built-in string.Template is safer and more powerful. It uses a simpler -based placeholder syntax and is designed to prevent accidental (or malicious) code injection.

from string import Template
# A template string that can be used to create a list
# Note the $placeholder syntax
template_str = "$greeting, $user! Your item '$item' is ready."
# Create a Template object
s = Template(template_str)
# A list of different data sets to plug into the template
data_sets = [
    {"greeting": "Hello", "user": "Bob", "item": "Laptop"},
    {"greeting": "Hi", "user": "Charlie", "item": "Book"},
    {"greeting": "Greetings", "user": "Diana", "item": "Coffee Mug"}
]
# Use a list comprehension to create the final list
final_messages = [s.safe_substitute(data) for data in data_sets]
# Print the result
for message in final_messages:
    print(message)

Output:

Hello, Bob! Your item 'Laptop' is ready.
Hi, Charlie! Your item 'Book' is ready.
Greetings, Diana! Your item 'Coffee Mug' is ready.

Key differences from str.format():

• Syntax: Uses $var or ${var} instead of {var}.
• Safety: s.substitute(data) will raise a KeyError if a key is missing. s.safe_substitute(data) will leave the placeholder ($var) in the string if the key is missing, which is often more robust.

Creating Lists of a Specific Type: "Template" for Data Structure

This is a very common pattern. You want to create a list where every element is a dictionary or an object with a predefined set of keys/attributes. This acts as a "template" for the structure of your data.

a) Using a Dictionary as a Template

You define a dictionary with default or None values and then create new dictionaries based on it.

# "Template" for a user record
user_template = {
    "id": None,
    "username": None,
    "email": None,
    "is_active": True
}
# Create a list of user records based on the template
users = []
users.append(user_template.copy()) # .copy() is crucial!
users.append(user_template.copy())
# Now, populate the data
users[0]["id"] = 1
users[0]["username"] = "alice"
users[0]["email"] = "alice@example.com"
users[1]["id"] = 2
users[1]["username"] = "bob"
users[1]["email"] = "bob@example.com"
# If you forget .copy(), all items will point to the SAME dictionary!
# bad_users = [user_template] * 2
# bad_users[0]["id"] = 1
# print(bad_users) -> [{'id': 1, ...}, {'id': 1, ...}] (Wrong!)
import pprint
pprint.pprint(users)

Output:

[{'email': 'alice@example.com',
  'id': 1,
  'is_active': True,
  'username': 'alice'},
 {'email': 'bob@example.com',
  'id': 2,
  'is_active': True,
  'username': 'bob'}]

b) Using dataclasses (Modern & Recommended)

For more structured data, Python's dataclasses are perfect. They act as a blueprint for creating objects.

from dataclasses import dataclass
# This is the "template" or blueprint for a product
@dataclass
class Product:
    name: str
    price: float
    in_stock: bool = True # Default value
# Now, create a list of Product instances
products = [
    Product(name="Laptop", price=1200.00),
    Product(name="Mouse", price=25.50, in_stock=False),
    Product(name="Keyboard", price=75.00)
]
# You can easily access the attributes
for product in products:
    print(f"- {product.name}: ${product.price:.2f} (In Stock: {product.in_stock})")

Output:

- Laptop: $120.00 (In Stock: True)
- Mouse: $25.50 (In Stock: False)
- Keyboard: $75.00 (In Stock: True)

Generating Lists from Templates (Jinja2)

For web development or complex text generation, the Jinja2 library is the industry standard. It's a powerful templating engine that can generate lists, HTML, or any other text format.

First, install it: pip install Jinja2

from jinja2 import Template
# A Jinja2 template string. It can use loops and logic.
template_str = """
<h1>User List</h1>
<ul>
{% for user in users %}
    <li>
        <strong>{{ user.name }}</strong> (Email: {{ user.email }})
        {% if user.is_active %}
            <span style="color: green;">(Active)</span>
        {% else %}
            <span style="color: red;">(Inactive)</span>
        {% endif %}
    </li>
{% endfor %}
</ul>
"""
# The data to be used in the template
users_data = [
    {"name": "Alice", "email": "alice@example.com", "is_active": True},
    {"name": "Bob", "email": "bob@example.com", "is_active": False},
    {"name": "Charlie", "email": "charlie@example.com", "is_active": True},
]
# Create a Template object
jinja_template = Template(template_str)
# Render the template with the data
output_html = jinja_template.render(users=users_data)
print(output_html)

Output:

<h1>User List</h1>
<ul>
    <li>
        <strong>Alice</strong> (Email: alice@example.com)
            <span style="color: green;">(Active)</span>
    </li>
    <li>
        <strong>Bob</strong> (Email: bob@example.com)
            <span style="color: red;">(Inactive)</span>
    </li>
    <li>
        <strong>Charlie</strong> (Email: charlie@example.com)
            <span style="color: green;">(Active)</span>
    </li>
</ul>

Summary: Which "Template" Should You Use?