Hàm map() trong Python: Hướng dẫn đầy đủ

Hàm map() của Python là một công cụ tích hợp mạnh mẽ cho phép áp dụng các mẫu lập trình hàm vào biến đổi dữ liệu. Nếu bạn muốn xử lý tập dữ liệu lớn, làm sạch dữ liệu văn bản hoặc thực hiện tính toán hàng loạt, thì hàm map() có thể rất hữu ích để tăng năng suất.

Trong hướng dẫn này, tôi sẽ giới thiệu cú pháp, các ứng dụng thực tế và kỹ thuật nâng cao của hàm map() trong Python. Chúng ta cũng sẽ xem xét đánh giá lười để tiết kiệm bộ nhớ, so sánh map() với các lựa chọn thay thế như list comprehension, và thảo luận các thực tiễn tốt nhất để đạt hiệu năng tối ưu.

Hiểu về iterator chỉ là bước đầu để viết mã hiệu quả. Để thực sự thành thạo thao tác dữ liệu, bạn cần một bộ công cụ lập trình Python đầy đủ, bao gồm mọi thứ từ xử lý lỗi đến các iterable nâng cao.

Cú pháp Python map()

Trước khi đi vào cách dùng map(), hãy xem cách hàm này hoạt động. Hiểu cú pháp và hành vi của nó sẽ giúp chúng ta áp dụng hiệu quả hơn.

Những điều cơ bản về hàm map()

Hàm map() là một tiện ích tích hợp của Python, áp dụng một hàm chỉ định lên mọi phần tử trong một iterable (như list, tuple, hoặc string) và trả về một iterator với kết quả đã biến đổi. Nhờ đó, nó thúc đẩy tính bất biến và khả năng tái sử dụng mã, những yếu tố quan trọng trong pipeline xử lý dữ liệu và tiền xử lý đặc trưng cho các mô hình máy học. 

Cú pháp rất đơn giản, như dưới đây:

map(function, iterable, ...) 

Tham số function, có thể là hàm tích hợp như len() hoặc hàm tùy biến, được áp dụng cho mọi phần tử trong iterable. Chúng ta cũng có thể truyền nhiều iterable để cho phép ánh xạ song song. Phần này sẽ được nói sau.

Khác với đánh giá háo hức (tính toán tất cả ngay lập tức), map() sử dụng đánh giá lười. Nó trả về một map object, là một iterator chỉ sinh giá trị khi được yêu cầu. Việc hoãn tính toán đến khi lặp giúp tiết kiệm bộ nhớ với các tập dữ liệu lớn.

Một ví dụ trực quan: bình phương các số:

numbers = [1, 2, 3, 4]
squared = map(lambda x: x**2, numbers)
print(list(squared))

[1, 4, 9, 16]

Giá trị tham số và giá trị trả về

Hàm map() yêu cầu tối thiểu hai tham số: một hàm có thể gọi và một iterable. Các iterable bổ sung (tùy chọn) cho phép broadcast hàm qua các dãy đã “zip”, rất phù hợp cho các phép toán dạng vector tương tự apply_along_axis() của NumPy.

Trong Python 3, map() trả về một map object, là một lớp con của iterator, thay vì một list. Sự thay đổi này tăng hiệu quả bộ nhớ vì không cấp phát không gian cho toàn bộ kết quả ngay từ đầu. Để vật hóa kết quả, hãy chuyển đổi tường minh:

• Sang list: list(map(function, iterable))

• Sang set: set(map(function, iterable))

• Lặp trực tiếp: for item in map(function, iterable): ..

Đoạn mã dưới đây minh họa việc chuyển đổi:

words = ['python', 'data', 'science']
# Converts map object to list
lengths = list(map(len, words)) 
print(lengths)

[6, 4, 7]

Để có cái nhìn nhanh về các thao tác Python khác nhau dùng trong suốt hướng dẫn này, tôi khuyến nghị bạn xem cheat sheet Python. 

Chuyển đổi từ Python 2 sang Python 3

Trong Python 2, map() trả về list theo kiểu háo hức, dễ làm phình bộ nhớ với đầu vào lớn — một cạm bẫy phổ biến trong các script dữ liệu cũ. Map object lười của Python 3 đã thay đổi điều này, phù hợp với giao thức iterator để mở rộng trong các môi trường dữ liệu lớn như PySpark.

Hệ quả? Xử lý mượt mà các tập dữ liệu khổng lồ mà không bị lỗi Out of Memory (OOM), dù bạn cần chuyển đổi tường minh để lập chỉ mục. Chẳng hạn, my_map[0] không hoạt động, nên phải dùng next(iter(my_map)) thay thế. 

Nếu bạn quen với tư duy dựa trên list, hãy xem khóa học Python cho người dùng MATLAB để chuyển dịch thuận lợi từ các phép toán vector sang iterator của Python.

Cách dùng map() trong Python

Giờ chúng ta đã nắm cơ bản, hãy triển khai map(). Ta sẽ xem những cách phổ biến nhất để áp dụng map(), từ các hàm tích hợp đơn giản đến biến đổi đa-iterable phức tạp hơn.

Cách dùng map() cơ bản

Cách trực quan nhất để dùng map() là với một hàm tích hợp. Giả sử bạn có một list chuỗi và muốn lấy độ dài của từng chuỗi. Để áp dụng map():

1. Xác định iterable: words = ['apple', 'banana', 'cherry']

2. Xác định hàm: Hàm tích hợp len().

3. Áp dụng map(): map(len, words)

4. Chuyển sang list: list(map(len, words)

Xem đoạn mã dưới đây:

words = ['apple', 'banana', 'cherry']

# Apply the len() function to each item in the list
lengths_map = map(len, words)

# Convert the map object to a list to see the results
lengths_list = list(lengths_map)

print(lengths_list)

[5, 6, 6]

Như ta thấy, cách này súc tích hơn so với viết một vòng lặp for, thêm phần tử vào list mới và quản lý trạng thái của list đó.

Dùng map() với hàm lambda

Nhiều khi thao tác bạn cần thực hiện đơn giản và ngắn hạn. Thay vì định nghĩa một hàm đầy đủ với def, bạn có thể dùng hàm lambda — một hàm ẩn danh nhỏ gọn trên một dòng.

Điều này rất phổ biến trong xử lý dữ liệu. Ví dụ, nếu bạn muốn bình phương một list số, thì hàm lambda là lựa chọn hoàn hảo. Xem ví dụ dưới đây:

numbers = [1, 2, 3, 4, 5]

# Use a lambda function to square each number
squared_map = map(lambda x: x * x, numbers)

squared_list = list(squared_map)
print(squared_list)

[1, 4, 9, 16, 25]

Khuyến nghị dùng lambda với map() trong các trường hợp sau:

• Phép biến đổi đơn giản (lý tưởng là một biểu thức duy nhất).

• Hàm đó không được tái sử dụng ở nơi khác trong mã.

Để biết thêm về hàm lambda, hãy xem hướng dẫn tương tác chi tiết về Python lambda.

Dùng map() với hàm do người dùng định nghĩa

Với các biến đổi phức tạp hơn hoặc lặp lại nhiều lần, hãy dùng hàm tùy biến định nghĩa với từ khóa def. Cách này giúp mã dễ đọc, mô-đun hóa và dễ kiểm thử hơn.

Giả sử bạn có list nhiệt độ theo độ C và cần chuyển sang độ F. Ta làm như sau:

def celsius_to_fahrenheit(c):
    # The formula is (Celsius * 9/5) + 32
    return (c * 9/5) + 32

celsius_temps = [0, 10, 25, 30.5, 100]

# Pass the user-defined function to map()
fahrenheit_map = map(celsius_to_fahrenheit, celsius_temps)

fahrenheit_list = list(fahrenheit_map)
print(fahrenheit_list)

[32.0, 50.0, 77.0, 86.9, 212.0]

Dùng một hàm có tên mô tả, như celsius_to_fahrenheit(), giúp thể hiện rõ mục đích của mã, là thực tiễn tốt cho mọi logic nghiệp vụ chuyên biệt.

Dùng map() với nhiều iterable

Một tính năng mạnh của map() là khả năng xử lý đồng thời nhiều iterable. Để làm được, hàm của bạn phải nhận số đối số bằng với số lượng iterable truyền vào.

Giả sử bạn có hai list số và muốn cộng chúng theo từng cặp phần tử:

list_a = [1, 2, 3, 4]
list_b = [10, 20, 30, 40]

# The lambda function now takes two arguments, x and y
sums_map = map(lambda x, y: x + y, list_a, list_b)

sums_list = list(sums_map)
print(sums_list)

[11, 22, 33, 44]

Nếu các iterable có độ dài khác nhau thì sao? Hàm map() sẽ dừng xử lý ngay khi iterable ngắn nhất hết phần tử, nên đầu ra sẽ có độ dài bằng iterable ngắn nhất. Ví dụ minh họa:

list_a = [1, 2, 3]          # Length 3
list_b = [10, 20, 30, 40]   # Length 4

# map() will stop after the 3rd element
short_map = map(lambda x, y: x + y, list_a, list_b)

print(list(short_map))

[11, 22, 33]

Hành vi này có thể dự đoán và hữu ích, ngăn các ngoại lệ IndexError. Nếu bạn cần xử lý tất cả phần tử và điền giá trị mặc định cho list ngắn hơn, bạn có thể dùng itertools.zip_longest(). 

Tiếp theo, hãy xem một số tình huống sử dụng thường gặp của map().

Các trường hợp dùng Python map() phổ biến

Hàm map() linh hoạt và rất hữu ích cho nhiều tác vụ xử lý và làm sạch dữ liệu phổ biến. Hãy xem nơi nào bạn sẽ thấy nó hữu dụng nhất.

Thực hiện tính toán trên list

Đây là trường hợp kinh điển. Khi bạn có một list số và cần áp dụng cùng một phép toán cho mọi phần tử, map() là giải pháp gọn gàng và hiệu quả.

Chúng ta đã thấy ví dụ tốt với chuyển đổi C sang F ở phần trước. Một kịch bản phổ biến khác là áp dụng công thức tài chính, như tính thuế bán hàng hoặc chuyển đổi tiền tệ.

Hãy tưởng tượng bạn có một list giá sản phẩm theo USD và cần đổi sang EUR. Làm như sau:

def usd_to_eur(price_usd):
    # Assuming a static exchange rate for this example
    EXCHANGE_RATE = 0.92
    return round(price_usd * EXCHANGE_RATE, 2)

prices_usd = [99.99, 150.00, 45.50, 78.25]

prices_eur_map = map(usd_to_eur, prices_usd)

print(list(prices_eur_map))

[91.99, 138.0, 41.86, 71.99]

Mẫu này dễ đọc hơn nhiều so với vòng lặp for, nhất là khi logic chuyển đổi phức tạp và tốt nhất nên đặt trong một hàm riêng.

Xử lý chuỗi hàng loạt

Làm sạch dữ liệu thường liên quan đến xử lý lượng lớn dữ liệu văn bản. Bạn có thể có hàng nghìn mục văn bản cần chuẩn hóa trước khi phân tích. Hàm map() rất phù hợp để áp dụng các phương thức chuỗi cho cả list.

Ví dụ, hãy làm sạch một list tên bằng cách loại bỏ khoảng trắng thừa và chuẩn hóa kiểu chữ:

raw_names = ['  Alice Smith ', ' bob johnson', 'Charlie Brown  ', ' david lee']

# Use map() with the built-in .strip() method
cleaned_names_map = map(str.strip, raw_names)

# Now chain another map() to convert to title case
# Note: we apply the second map to the *results* of the first map
final_names_map = map(str.title, cleaned_names_map)

print(list(final_names_map))

['Alice Smith', 'Bob Johnson', 'Charlie Brown', 'David Lee']

Khả năng xâu chuỗi các thao tác map() (vì mỗi thao tác trả về một iterator) rất quan trọng để xử lý pipeline dữ liệu hiệu quả. 

Lọc và ánh xạ dữ liệu

Nhiều khi bạn không muốn biến đổi mọi phần tử. Bạn chỉ muốn biến đổi những phần tử thỏa điều kiện. Đây là mẫu thường gặp trong phân tích dữ liệu, và dễ dàng giải bằng cách kết hợp map() với filter() của Python.

Hàm filter(function, iterable) hoạt động tương tự map(), nhưng nó chỉ trả về các phần tử mà hàm cho kết quả True. 

Giả sử chúng ta có list số đo cảm biến và muốn chỉ bình phương các giá trị dương, bỏ qua số âm (có thể là lỗi). Ta làm như sau:

1. Lọc: Đầu tiên dùng filter() để lấy số dương.

2. Ánh xạ: Sau đó dùng map() để bình phương các kết quả đã lọc.

readings = [10, -5, 3, -1, 20, 0]

# 1. Filter out the negative numbers
positive_readings = filter(lambda x: x > 0, readings)

# 2. Map the squaring function to the filtered iterator
squared_positives = map(lambda x: x * x, positive_readings)

print(list(squared_positives))

[100, 9, 400]

Vì cả map() và filter() đều là lười, quy trình hai bước này rất tiết kiệm bộ nhớ. Không tạo list trung gian. Mẫu filter-rồi-map là lựa chọn mạnh mẽ thay cho một list comprehension phức tạp hơn.

Ví dụ map() thực tiễn

Giờ chúng ta đã thấy các khái niệm cơ bản và trường hợp dùng phổ biến, hãy xem một số ví dụ cụ thể cho thấy map() mang lại cú pháp gọn và hiệu quả cho nhiều tác vụ biến đổi dữ liệu.

Chuyển sang chữ hoa

Đây là tác vụ xử lý chuỗi kinh điển. Với một list chuỗi, bạn có thể dùng map() cùng phương thức tích hợp str.upper() để chuyển mọi phần tử sang chữ hoa, như dưới đây:

words = ['data science', 'python', 'map function']

# Apply the str.upper method to each item
upper_words = map(str.upper, words)

print(list(upper_words))

['DATA SCIENCE', 'PYTHON', 'MAP FUNCTION']

Trích ký tự đầu tiên từ chuỗi

Đôi khi bạn cần trích thông tin cụ thể từ mỗi phần tử. Ở đây, ta có thể dùng lambda để lấy ký tự đầu tiên (ở chỉ số 0) của từng chuỗi trong list.

names = ['Alice', 'Bob', 'Charlie']

# Use a lambda function to get the character at index 0
first_chars = map(lambda s: s[0], names)

print(list(first_chars))

['A', 'B', 'C']

Loại bỏ khoảng trắng khỏi chuỗi

Như đã thấy ở phần xử lý chuỗi, làm sạch khoảng trắng là bước cơ bản trong chuẩn bị dữ liệu văn bản. Dùng map() với str.strip() là cách Pythonic nhất để làm việc này.

raw_data = ['  value1 ', ' value2  ', '  value3']

# Apply the str.strip method
cleaned_data = map(str.strip, raw_data)

print(list(cleaned_data))

['value1', 'value2', 'value3']

Để biết thêm cách xử lý dữ liệu chuỗi và list, hướng dẫn tương tác về các hàm và phương thức list trong Python cung cấp rất nhiều ví dụ.

Cập nhật dữ liệu trong các framework (ví dụ: Django)

Trong ứng dụng web hoặc hướng dữ liệu, bạn thường nhận dữ liệu dạng list các dictionary (như payload JSON). Hàm map() có thể dùng để chuẩn bị dữ liệu trước khi cập nhật cơ sở dữ liệu, như trong Django hoặc khi làm việc với MongoDB.

Giả sử có list dictionary đại diện cho các cập nhật sản phẩm, và ta cần thêm dấu thời gian processed vào mỗi bản ghi trước khi gửi lên cơ sở dữ liệu:

import datetime

def add_timestamp(record):
    # Don't modify the original! Return a new copy.
    new_record = record.copy() 
    new_record['processed_at'] = datetime.datetime.now()
    return new_record

product_updates = [
    {'id': 101, 'price': 50.00},
    {'id': 102, 'price': 120.50},
    {'id': 103, 'price': 75.25}
]

processed_data = map(add_timestamp, product_updates)

print(list(processed_data))

[{'id': 101, 'price': 50.0, 'processed_at': datetime.datetime(2025, 11, 11, 13, 40, 25, 123456)}, 
 {'id': 102, 'price': 120.5, 'processed_at': datetime.datetime(2025, 11, 11, 13, 40, 25, 123457)}, 
 {'id': 103, 'price': 75.25, 'processed_at': datetime.datetime(2025, 11, 11, 13, 40, 25, 123458)}]

Mẫu này lý tưởng cho cập nhật hàng loạt và cho thấy giá trị của việc thông thạo dictionary.

Sinh phần tử HTML

Với nhà phát triển web, map() có thể là một template engine đơn giản. Bạn có thể biến một list dữ liệu thành list chuỗi HTML sẵn sàng render. Ví dụ dưới đây biến một list Python thành danh sách HTML không thứ tự:

def create_list_item(text):
    return f"<li>{text}</li>"

menu_items = ['Home', 'About', 'Contact']

# Map the function to the list
html_items = map(create_list_item, menu_items)

# Join the results into a single string
html_list = "\n".join(html_items)

print(f"<ul>\n{html_list}\n</ul>")

<ul>
<li>Home</li>
<li>About</li>
<li>Contact</li>
</ul>

Ứng dụng nâng cao của Python map()

Mặc dù map() rất tuyệt cho các biến đổi một-đổi-một đơn giản, sức mạnh thực sự của nó thể hiện ở các kịch bản phức tạp hơn. Hãy xem một số mẫu nâng cao nơi map() là thành phần chủ chốt trong chiến lược xử lý dữ liệu tinh vi.

Xử lý nhiều iterable

Chúng ta đã đề cập đến việc dùng map() với nhiều iterable, và đây là mẫu nền tảng cho nhiều bài toán dữ liệu và khoa học nâng cao. Khi truyền nhiều iterable, map() hoạt động như khóa kéo, đưa phần tử thứ i từ mỗi iterable vào hàm của bạn, nghĩa là số đối số phải khớp số iterable.

Ví dụ, để tính tổng giá trị của các sản phẩm trong kho, bạn có thể có ba list riêng. Hãy xem map() được dùng như thế nào ở đây:

product_ids = ['A-101', 'B-202', 'C-303']
quantities = [50, 75, 30]
prices = [10.99, 5.49, 20.00]

# A function that takes three arguments
def calculate_line_total(pid, qty, price):
    # Returns a tuple of (id, total_value)
    return (pid, round(qty * price, 2))

# map() feeds one element from each list into the function
line_totals = map(calculate_line_total, product_ids, quantities, prices)

print(list(line_totals))

[('A-101', 549.5), ('B-202', 411.75), ('C-303', 600.0)]

Như đã lưu ý, map() dừng ở iterable ngắn nhất. Đây là chủ đích để ngăn IndexError. Nếu logic yêu cầu xử lý tất cả phần tử từ list dài nhất (ví dụ cần điền giá trị mặc định), hãy dùng itertools.zip_longest() thay thế. Bạn có thể học cùng nhiều hàm hữu ích khác trong khóa viết mã Python hiệu quả.

itertools.starmap() cho iterable lồng nhau

Điều gì xảy ra khi dữ liệu của bạn đã được “zip” thành list các tuple? Điều này cực kỳ phổ biến khi làm với kết quả truy vấn cơ sở dữ liệu, tệp CSV, hoặc cặp tọa độ.

Giả sử bạn có list điểm (x,y) như dưới đây và bạn muốn tính tích của từng cặp.

points = [(1, 5), (3, 9), (4, -2)]

Bạn có thể dùng lambda với map(), nhưng sẽ hơi gượng nếu có hàm lồng dài phía trong:

list(map(lambda p: p[0] * p[1], points))

Giải pháp rõ ràng, “Pythonic” hơn là itertools.starmap(). Nó nhận một hàm và một iterable đơn gồm các iterable con (như list tuple của ta), rồi unpack từng tuple con thành đối số cho hàm. Xem ví dụ:

import itertools

points = [(1, 5), (3, 9), (4, -2)]

# A simple function that takes two arguments
def product(x, y):
    return x * y

# starmap() unpacks each tuple from 'points' into (x, y)
# and passes them to product()
products = itertools.starmap(product, points)

print(list(products))

[5, 27, -8]

starmap() là công cụ đúng đắn khi đối số của hàm đã được gói sẵn trong các tuple. Mẫu này đặc biệt hữu ích khi xử lý dữ liệu không gian, như list tọa độ (vĩ độ, kinh độ). Để tìm hiểu sâu hơn, tôi khuyến nghị khóa học về làm việc với dữ liệu địa lý trong Python.

Tích hợp lập trình hàm

Hàm map() rất hữu ích trong lập trình hàm. Ta có thể kết hợp nó với các công cụ hàm khác như filter() và functools.reduce() để xây dựng pipeline xử lý dữ liệu gọn gàng và hiệu quả cao.

Chúng ta đã thấy sự kết hợp filter() và map(). Giờ hãy xem cách dùng reduce(), hàm gộp ("rút gọn") một iterable thành một giá trị tích lũy duy nhất.

Giả sử bạn muốn tính tổng bình phương của các số lẻ trong một list. Ta làm như sau:

from functools import reduce

numbers = [1, 2, 3, 4, 5, 6, 7]

# 1. Filter: Get only the odd numbers
odd_numbers = filter(lambda x: x % 2 != 0, numbers)
# -> Iterator(1, 3, 5, 7)

# 2. Map: Square the odd numbers
squared_odds = map(lambda x: x * x, odd_numbers)
# -> Iterator(1, 9, 25, 49)

# 3. Reduce: Sum the results
#    (lambda a, b: a + b) is the summing function
#    'a' is the accumulator, 'b' is the next item
total = reduce(lambda acc, val: acc + val, squared_odds)

print(total)

84

Đây là một mẫu mạnh mẽ. Vì map() và filter() đều trả về iterator lười, toàn bộ thao tác này cực kỳ tiết kiệm bộ nhớ. Không có list trung gian lớn nào được tạo ra. Dữ liệu chảy qua pipeline, từng phần tử một. 

Đánh giá lười và quản lý bộ nhớ

Một trong những tính năng quan trọng nhất của map() trong Python 3 là sử dụng đánh giá lười. Hiểu khái niệm này là cần thiết để viết mã hiệu quả, có khả năng mở rộng, đặc biệt với người làm dữ liệu thường xuyên xử lý tập dữ liệu lớn. Ở phần này, ta sẽ xem nó hoạt động thế nào.

Lợi ích của đánh giá lười

Trong Python 3, map() không chạy hàm của bạn ngay và trả về list. Thay vào đó, nó trả về một đối tượng map, vốn là một iterator. Iterator này “biết” dùng hàm nào và dữ liệu nào, nhưng không thực sự tính cho đến khi bạn yêu cầu phần tử tiếp theo.

Kiểu tính “đúng lúc” này có nhiều lợi ích lớn, như:

• Hiệu quả bộ nhớ: Một đối tượng map chỉ chiếm một lượng bộ nhớ nhỏ, cố định, bất kể xử lý 10 phần tử hay 10 tỷ. Nó không tạo list mới trong bộ nhớ để chứa toàn bộ kết quả.

• Hiệu năng với dữ liệu lớn: Khi bạn lặp qua đối tượng map (ví dụ trong vòng lặp for), nó tính và sinh từng giá trị một. Điều này cho phép xử lý các tệp lớn hay luồng dữ liệu quá lớn để nạp toàn bộ vào bộ nhớ cùng lúc.

• Khả năng xâu chuỗi: Như đã thấy trong phần lập trình hàm, các iterator lười có thể xâu chuỗi (ví dụ, map() sau filter()). Vì không có list trung gian được tạo, dữ liệu chảy qua pipeline từng phần tử một, rất hiệu quả.

So sánh với list comprehension, vốn dùng đánh giá háo hức. Xem ví dụ:

squared = [x * x for x in range(10000000)]

Đoạn mã này sẽ cố tạo một list gồm 10 triệu số ngay lập tức, có thể tiêu thụ lượng RAM khổng lồ.

Dùng biểu thức generator

Biểu thức generator là phiên bản lười của list comprehension. Trông rất giống nhau nhưng hành xử giống map() về mặt bộ nhớ. 

squared = (x * x for x in range(10000000))

Đoạn trên cũng tạo ra một iterator tiết kiệm bộ nhớ, tương tự map(). Việc chọn map() hay biểu thức generator thường phụ thuộc vào tính dễ đọc. map() có thể rõ ràng hơn khi áp dụng một hàm có sẵn, phức tạp; trong khi generator thường dễ đọc hơn cho biểu thức đơn giản, inline. 

Hãy so sánh mức dùng bộ nhớ cho các thao tác này:

import tracemalloc

# Define the base data for comparison
large_numbers = range(10000000)

print("--- Memory Usage (Object Creation vs. List Materialization) ---")

# --- 1. Memory for List Comprehension (creates full list immediately) ---
tracemalloc.start()
list_comp_obj = [x * x for x in large_numbers]
current, peak = tracemalloc.get_traced_memory()
tracemalloc.stop()
print(f"Peak RAM for List Comprehension (full list): {peak / (1024 * 1024):.2f} MB")
del list_comp_obj  # Free up memory


# --- 2. Memory for Map Object (lazy) ---
tracemalloc.start()
map_obj = map(lambda x: x * x, large_numbers)
current, peak = tracemalloc.get_traced_memory()
tracemalloc.stop()
print(f"Peak RAM for Map Object (iterator itself): {peak / (1024 * 1024):.2f} MB")
del map_obj  # Free up memory


# --- 3. Memory for Generator Expression (lazy) ---
tracemalloc.start()
gen_exp_obj = (x * x for x in large_numbers)
current, peak = tracemalloc.get_traced_memory()
tracemalloc.stop()
print(f"Peak RAM for Generator Expression (iterator itself): {peak / (1024 * 1024):.2f} MB")
del gen_exp_obj  # Free up memory

--- Memory Usage (Object Creation vs. List Materialization) ---
Peak RAM for List Comprehension (full list): 390.16 MB
Peak RAM for Map Object (iterator itself): 0.03 MB
Peak RAM for Generator Expression (iterator itself): 0.03 MB

Lưu ý: 'Peak RAM' cho Map/Generator ở đây là bộ nhớ cấp cho chính đối tượng iterator, không phải bộ nhớ của toàn bộ list nếu chuyển đổi — cho thấy bản chất lười của chúng.

Chuyển map object thành các iterable

Vì map() trả về iterator lười, bạn thường cần vật hóa hoặc chuyển nó thành cấu trúc cụ thể để thực sự dùng kết quả.

Bạn nên chuyển một đối tượng map khi cần:

• Xem tất cả kết quả cùng lúc (ví dụ dùng print()).

• Truy cập phần tử theo chỉ số (ví dụ results[0]).

• Lấy độ dài kết quả (ví dụ len(results)).

• Truyền kết quả cho hàm yêu cầu list hoặc set.

• Lặp nhiều lần qua kết quả. (Đối tượng map, như mọi iterator, có thể bị “tiêu hao”. Bạn chỉ lặp qua một lần.)

Cách chuyển một đối tượng map:

def square(x):
    return x * x

numbers = [1, 2, 3, 3, 4, 5]
map_obj = map(square, numbers)

# --- Common Conversions ---

# 1. To a list:
list_results = list(map_obj) 
print(f"List: {list_results}")

# Important 
# The map_obj is now exhausted. 
# If you try to do list(map_obj) again, you'll get an empty list.
# You must re-create the map object to reuse it.

map_obj = map(square, numbers) # Re-create it

# 2. To a set (removes duplicates):
set_results = set(map_obj)
print(f"Set: {set_results}")

map_obj = map(square, numbers) # Re-create it

# 3. To a tuple:
tuple_results = tuple(map_obj)
print(f"Tuple: {tuple_results}")

List: [1, 4, 9, 9, 16, 25] 
Set: {1, 4, 9, 16, 25} 
Tuple: (1, 4, 9, 9, 16, 25)

Để chuyển sang dictionary (nếu đầu ra là cặp khóa-giá trị), bạn có thể dùng map() với dict(), nhưng thường dictionary comprehension của Python sẽ rõ ràng hơn.

Điều quan trọng cần nhớ là có chủ đích. Hãy để map() ở dạng iterator lười lâu nhất có thể trong pipeline, và chỉ chuyển sang list ở bước cuối cùng khi bạn thực sự cần kết quả cụ thể.