Of course. Using a Counter in Python 2.6 requires a bit of extra work because the collections.Counter class was introduced in Python 2.7.

Here’s a complete guide covering the best ways to achieve a counter-like functionality in Python 2.6, from manual methods to the recommended third-party solution.

The Short Answer: Use collections.Counter (if you can upgrade)

The best solution is to upgrade your Python version. Counter is a fantastic and highly optimized tool. If you have any control over your environment, please consider upgrading to Python 2.7 or a modern version like Python 3.

Method 1: The Manual Approach (No Imports Needed)

If you cannot upgrade Python or install any third-party packages, you can easily replicate the core functionality of a Counter using a standard Python dictionary. This is a great way to understand what Counter does under the hood.

The main features of a Counter are:

1. Counting items in an iterable.
2. Handling missing keys gracefully (returning 0 instead of a KeyError).
3. Providing common methods like most_common().

Here is how you can implement this:

# A simple dictionary to act as our counter
item_counts = {}
# 1. Counting items from a list
my_list = ['apple', 'banana', 'apple', 'orange', 'banana', 'apple']
for item in my_list:
    # The .get(key, 0) method is key here. It returns the value for 'item'
    # if it exists, or it returns the default value 0 if it doesn't.
    item_counts[item] = item_counts.get(item, 0) + 1
print "--- Manual Counter Results ---"
print item_counts
# Output: {'orange': 1, 'apple': 3, 'banana': 2}
# 2. Simulating the most_common() method
def get_most_common(counts_dict, n=1):
    # Sort the items by their count (the value) in descending order
    # The `key=lambda item: item[1]` tells sort to look at the second element of each tuple
    sorted_items = sorted(counts_dict.items(), key=lambda item: item[1], reverse=True)
    return sorted_items[:n]
print "\nTop 2 most common items:"
print get_most_common(item_counts, 2)
# Output: [('apple', 3), ('banana', 2)]

Method 2: The Recommended Third-Party Solution (backports)

If you want to use the actual collections.Counter class without upgrading your entire Python installation, you can install a backport package. This is the cleanest and most robust solution if you can use pip.

The most common backport is backports.collections.

Step 1: Install the backport package

pip install backports.collections

Step 2: Use it in your code

You must import it from the backports module, not the standard collections.

# IMPORTANT: Import from the backports module
from backports.collections import Counter
my_list = ['apple', 'banana', 'apple', 'orange', 'banana', 'apple']
# Now you can use Counter just like in Python 2.7+
c = Counter(my_list)
print "--- backports.collections.Counter Results ---"
print c
# Output: Counter({'apple': 3, 'banana': 2, 'orange': 1})
# Use its built-in methods
print "\nTop 2 most common items:"
print c.most_common(2)
# Output: [('apple', 3), ('banana', 2)]
# Access counts, which returns 0 for missing keys
print "\nCount of 'pear':", c['pear']
# Output: Count of 'pear': 0

Comparison of Methods

Final Recommendation

1. If you can upgrade your Python version: Do it. This is the best long-term solution.
2. If you can use pip: Install backports.collections. This gives you the correct, high-performance tool with minimal effort.
3. If you have strict no-dependency rules: Use the manual dictionary approach. It's simple, effective, and requires no external packages or upgrades.