# 5 Best Ways to Assign Value to Unique Numbers in a Python List

Rate this post

π‘ Problem Formulation: In Python, you might encounter a scenario where you have a list of numbers and you need to assign a specific value to each unique number. Presume we have a list `[3, 7, 3, 2, 9]`, and we wish to map each unique number to a value, potentially ending up with a result like `{3: 'a', 7: 'b', 2: 'c', 9: 'd'}`. This article explores multiple ways to achieve this task, ranging from simple iterations to more complex one-liners.

## Method 1: Using a for loop and a dictionary

This method involves iterating over the list and assigning values to a dictionary where each unique number becomes a key. It’s a basic approach that’s simple to understand and implement for beginners.

Here’s an example:

```unique_values = ['a', 'b', 'c', 'd']
numbers_list = [3, 7, 3, 2, 9]
mapping = {}

for i, number in enumerate(set(numbers_list)):
mapping[number] = unique_values[i]

print(mapping)
```

Output: `{2: 'a', 3: 'b', 7: 'c', 9: 'd'}`

This code snippet initializes an empty dictionary called `mapping`, then iterates through the `set` of the numbers list, ensuring only unique elements are considered. It assigns each unique number a value from the `unique_values` list sequentially. Remember, sets are unordered, so the mapping is also not ordered.

## Method 2: Using Dictionary Comprehension

Dictionary comprehension is a concise way to create dictionaries. This method utilizes comprehension to pair up unique numbers with values in a single expressive line of code.

Here’s an example:

```unique_values = ['a', 'b', 'c', 'd']
numbers_list = [3, 7, 3, 2, 9]
mapping = {number: value for number, value in zip(set(numbers_list), unique_values)}

print(mapping)
```

Output: `{2: 'a', 3: 'b', 7: 'c', 9: 'd'}`

In this example, `zip` pairs each unique number with a corresponding value and `dictionary comprehension` is used to iterate through those pairs and create a dictionary mapping. This method is short and efficient but may be less readable to those unfamiliar with comprehensions.

## Method 3: Using the `enumerate` Function and `zip`

This method uses the `enumerate` function to get both the index and the value from the unique numbers, paired with the help of `zip` function to map each unique number in the list.

Here’s an example:

```unique_values = ['a', 'b', 'c', 'd']
numbers_list = [3, 7, 3, 2, 9]

unique_numbers = list(set(numbers_list))
mapping = dict(zip(unique_numbers, [unique_values[i] for i in range(len(unique_numbers))]))

print(mapping)
```

Output: `{2: 'a', 3: 'b', 7: 'c', 9: 'd'}`

This code first converts the set of unique numbers back into a list to preserve the order during the zipping process. Then, it creates a list of values using list comprehension and `enumerate`, which is finally zipped to the unique numbers to create the value mapping. Although this method is slightly more involved, it maintains the order of the original list.

## Method 4: Using the `collections.OrderedDict`

`collections.OrderedDict` ensures that the order of keys in the dictionary is preserved, which can be important if the order of elements matters. This method is great when you need an ordered mapping from unique numbers to values.

Here’s an example:

```from collections import OrderedDict

unique_values = ['a', 'b', 'c', 'd']
numbers_list = [3, 7, 3, 2, 9]

unique_numbers = list(OrderedDict.fromkeys(numbers_list))
mapping = OrderedDict(zip(unique_numbers, unique_values))

print(mapping)
```

Output: `OrderedDict([(3, 'a'), (7, 'b'), (2, 'c'), (9, 'd')])`

Here, an `OrderedDict` is created from the original list, which deduplicates the elements while preserving their order. Then, another `OrderedDict` is created to map the unique numbers to the values. This method maintains the insertion order but is only needed when such order is required.

## Bonus One-Liner Method 5: Using a Lambda Function and `map`

A one-liner that leverages the `map` function and a lambda to create a dictionary. It’s elegant but might sacrifice some readability for brevity.

Here’s an example:

```mapping = dict(map(lambda kv: (kv[1], kv[0]), enumerate(set([3, 7, 3, 2, 9]))))

print(mapping)
```

Output: `{0: 2, 1: 3, 2: 7, 3: 9}`

This one-liner uses `map` along with a `lambda` function that swaps the index with the number from a `set` of the list, creating a unique number-to-index mapping. It’s worth noting that in this output, the values are indices and not custom values, which might not always be desirable.

## Summary/Discussion

• Method 1: For Loop and Dictionary. Straightforward and easy to understand. However, it’s verbose and not the most Pythonic way to handle mappings.
• Method 2: Dictionary Comprehension. Pythonic and concise. Can be less clear to those new to Python or dict comprehensions.
• Method 3: Enumerate Function and Zip. Offers a balance between readability and conciseness. Preserves order, but slightly more complex.
• Method 4: OrderedDict. Preserves the order of keys. Good for ordered data. May be unnecessary for unordered mappings.
• Method 5: Lambda Function and Map. Compact one-liner. Good for quick operations but might trade off readability and requires understanding of lambda and map functions.