Introduction: Python Dictionary values() Method
When working with dictionaries, there are many situations where you only need the values without caring about the keys. Writing extra logic to extract values manually can make the code longer and less efficient.
This is where the Python dictionary values() method becomes useful.
What it is: The values() method is a built-in Python dictionary method that returns all values stored in a dictionary as a dynamic view object.
This allows you to access and work with dictionary values directly without manually extracting them.
Take a look at a quick example to see the values() method in action.
You can also explore its real-world use cases.
Now let’s understand its syntax, parameters, and how the values() method works in Python before moving on to use cases and examples.
Tip: The values() method is part of Python’s dictionary view system. If you’d like to understand dictionaries from the ground up, see Learn Python Dictionaries from Scratch.
Syntax, Parameters, Return Value and Examples: Python Dictionary values() Method
Syntax
dictionary.values()Parameters
| Parameter | Description | Required |
|---|---|---|
| None | The values() method does not take any arguments | No |
The values() method directly returns all values stored in the dictionary.
Return Value
It returns a dynamic dict_values object containing all the values from the dictionary. This object is dynamic and reflects changes made to the dictionary.
Quick Example
Before moving deeper, let’s quickly see how values() works in action.
data = {"name": "Alice", "age": 25, "city": "New York"}
values = data.values()
print(values)
# Output:
dict_values(['Alice', 25, 'New York'])
The method returns all stored values as a dynamic view object.
How the Python dictionary values() method works
- The values() method retrieves all stored values and returns them as a view object.
- Since the returned object is dynamic, changes made to the dictionary are reflected automatically.
- It does not create a separate copy, which makes it memory-efficient.
- You can iterate over the returned object or convert it into a list, set, or tuple when needed.
Examples: Dictionary values() Method
To understand how values() behaves in different scenarios, let’s go through practical examples from basic to advanced scenarios.
Example 1: Convert Values to List
fruit_prices = {"apple": 50, "banana": 20, "cherry": 75}
prices = list(fruit_prices.values())
print(prices)
# Output:
[50, 20, 75]
Explanation: Converts the values view into a list for easier processing.
Example 2: Check if a Value Exists
fruit_prices = {"apple": 50, "banana": 20, "cherry": 75}
print(75 in fruit_prices.values())
# Output:
True
Explanation: Uses values() with the in operator to check whether a particular value exists in the dictionary.
Example 3: Iterate Over Values
fruit_prices = {"apple": 50, "banana": 20, "cherry": 75}
for price in fruit_prices.values():
print(price)
# Output:
50
20
75
Explanation: Iterates through all dictionary values one by one.
Example 4: Sum All Values
fruit_prices = {"apple": 50, "banana": 20, "cherry": 75}
print(sum(fruit_prices.values()))
# Output:
145
Explanation: Calculates the total of all dictionary values using sum().
Example 5: Count Frequency of Values
from collections import Counter
marks = {"A": 90, "B": 85, "C": 90, "D": 85}
print(Counter(marks.values()))
# Output:
Counter({90: 2, 85: 2})
Explanation: Counts how often each value appears using Counter.
Example 6: Filter Dictionary Based on Values
fruit_prices = {"apple": 50, "banana": 20, "cherry": 75}
high_prices = [price for price in fruit_prices.values() if price > 30]
print(high_prices)
# Output:
[50, 75]
Explanation: The values() method returns all dictionary values. The list comprehension filters those values and keeps only the ones greater than 30.
Example 7: Compare Values of Two Dictionaries
fruit_prices = {"apple": 50, "banana": 20, "cherry": 75}
new_prices = {"apple": 55, "banana": 20, "cherry": 70}
common = set(fruit_prices.values()) & set(new_prices.values())
print(common)
# Output:
{20}
Explanation: Finds common values between two dictionaries.
Example 8: Access Nested Dictionary Values
products = {
"item1": {"price": 100, "stock": 50},
"item2": {"price": 80, "stock": 20},
}
for item in products.values():
print(item["price"])
# Output:
100
80
Explanation: Accesses the inner dictionary values and prints the price of each product.
Real-World Use Cases: Dictionary values() Method
Now that you understand how it works, let’s look at practical situations where Python dictionary values() method is commonly used:
- Iterating through all values stored in a dictionary
- Performing calculations such as sum, average, minimum, or maximum
- Filtering or analyzing data based on dictionary values
- Checking whether specific or duplicate values exist
- Extracting values from nested dictionaries for processing
- Converting dictionary values into lists, tuples, or sets
Key Takeaways: Dictionary values() Method
Here are the most important concepts to remember about the dictionary values() method in Python:
- Returns a dynamic view object containing all dictionary values
- Automatically reflects updates made to the original dictionary
- Does not create or modify dictionary keys
- Can be used directly in loops and conditional checks
- Supports conversion into list, tuple, or set when needed
- Useful for calculations, filtering, searching, and data analysis
- Provides an efficient way to access dictionary values without extra indexing
Overall, the Python dictionary values() method helps simplify value-based operations and makes dictionary data easier to process and analyze.