Biểu tượng chim cắt của Kestrel Exams KESTREL EXAMSLUYỆN TẬP ĐỂ ĐẠT
Bản dịch này do AI thực hiện và chưa được người bản ngữ kiểm duyệt. Nếu có khác biệt, bản tiếng Anh là bản chính. Mã nguồn được giữ nguyên bằng tiếng Anh. Ứng dụng luyện tập và tài liệu cho các kỳ thi chứng chỉ của Hoa Kỳ chỉ có bằng tiếng Anh. Read in English
PythonĐọc trong 9 phútMã đã được kiểm chứng

Vì sao sửa danh sách này lại làm đổi danh sách kia

Bốn dòng mã trông có vẻ hiển nhiên nhưng không phải vậy. Đây là ý tưởng mà các môn Python nhập môn kiểm tra gắt gao nhất, vì đây là điều bạn có thể hiểu sai mà chương trình không hề bị dừng vì lỗi. Mọi kết quả trên trang này đều đã được chạy thật, không phải nhớ lại.

Luyện tập chủ đề này trong ứng dụng miễn phí →Tất cả bài hướng dẫn Python

Hai người, một cuốn sổ#

Bạn và một người bạn đang chuẩn bị hành lý cho chuyến đi. Bạn viết danh sách đồ cần mang vào một cuốn sổ và để trên bàn bếp. Người bạn hỏi danh sách ở đâu. Bạn trả lời: trên bàn bếp.

Người bạn đến đó và gạch bỏ “lều”.

Danh sách của bạn đã thay đổi. Không phải một bản sao của danh sách. Chính danh sách của bạn. Bạn chưa bao giờ đưa cho người kia cuốn sổ thứ hai. Bạn đã đưa chỉ dẫn đến cuốn sổ duy nhất mà bạn đang có.

Đó là toàn bộ nội dung của trang này. Trong Python, một tên không phải là cái hộp có giá trị bên trong. Một tên là cái nhãn trỏ vào một thứ gì đó. Đặt tên thứ hai cho một danh sách là bạn đã viết cùng một chỉ dẫn hai lần, và tên nào cũng có thể đi đến đó và thay đổi danh sách duy nhất ấy.

Photocopy cuốn sổ trước thì cả hai đều an toàn. Python cũng có máy photocopy. Biết khi nào cần đến nó chính là sự khác biệt giữa một chương trình chạy đúng và một chương trình âm thầm làm hỏng dữ liệu của bạn.

Bốn dòng mã#

Hãy đoán đầu ra (output) trước khi cuộn xuống. Bốn dòng, không có gì cầu kỳ:

x = [0, 1, 2]
y = x
x[0] = 99
print(y)
[99, 1, 2]

Không có gì được làm với y cả. Dòng thứ ba chỉ nhắc đến x. Vậy mà y đã thay đổi.

Hầu như ai cũng đọc dòng 2 là “tạo một bản sao của x và gọi nó là y.” Nó không làm vậy. Nó tạo một cái tên thứ hai cho danh sách duy nhất đã tồn tại. Sau dòng 2, trong bộ nhớ vẫn chỉ có một danh sách; chỉ là nó có hai tên. Dòng 3 chạm đến danh sách đó qua tên x, và dòng 4 nhìn vào cùng danh sách đó qua tên y.

Từ để chỉ điều này là bí danh (aliasing): hai hoặc nhiều tên cùng trỏ vào một đối tượng. Bạn cũng sẽ thấy nó được viết là hai tên gắn (bound) với một đối tượng, nghĩa vẫn như nhau: một tên được gắn với một giá trị ngay lúc bạn gán nó.

Vì sao số và chuỗi có vẻ miễn nhiễm#

Đây là cùng một dạng, với số nguyên (integer) thay cho danh sách:

a = 5
b = a
a = 99
print(b)
5

Đây là phép so sánh mà các bài thi rất thích, vì hai kết quả trông mâu thuẫn nhưng thật ra không phải. Sự khác biệt không phải là số được sao chép còn danh sách thì không. Sự khác biệt là dòng 3 làm gì.

  • x[0] = 99 biến đổi (mutate): nó đi vào bên trong danh sách hiện có và thay đổi một phần của danh sách đó. Bất cứ ai đang nhìn danh sách đó đều thấy thay đổi.
  • a = 99 gán lại (rebind): nó trỏ tên a vào một giá trị hoàn toàn khác. Giá trị cũ không bị đụng đến, và b vẫn đang trỏ vào nó.

Số nguyên, số thực (float), giá trị Boolean, chuỗi (string) và tuple (bộ giá trị) là bất biến (immutable): không có thao tác nào thay đổi chúng tại chỗ, nên gán lại là điều duy nhất có thể xảy ra với chúng. Danh sách và từ điển (dictionary) là khả biến (mutable), nên cả hai thao tác đều dùng được, và chỉ một trong hai được tên kia nhìn thấy.

Chuỗi cho thấy rõ điều này, vì chúng hoạt động giống số dù trông giống một danh sách ký tự:

word = "hello"
word2 = word
word = word + "!"
print(word2)
hello

word + "!" không thể sửa "hello": nó tạo một chuỗi hoàn toàn mới và gán lại word vào đó. Nếu cố biến đổi trực tiếp một chuỗi, Python sẽ chặn bạn ngay:

greeting = "Hello, world!"
greeting[0] = "J"
Traceback (most recent call last):
  File "greet.py", line 2, in <module>
    greeting[0] = "J"
    ~~~~~~~~^^^
TypeError: 'str' object does not support item assignment
Một câu để mang vào phòng thi

Phép gán (assignment) không bao giờ sao chép. Nó chỉ gắn một tên. Điều đó có quan trọng hay không hoàn toàn phụ thuộc vào việc thứ được gắn có thể bị biến đổi hay không.

Chứng minh bằng is#

== hỏi “chúng có chứa cùng các giá trị không?” is hỏi câu chính xác hơn: “chúng có phải cùng một đối tượng không?”

x = [1, 2]
y = x
z = x[:]
print(x is y)
print(x is z)
print(x == z)
True
False
True

Đọc chúng thành tiếng thì sự khác biệt không còn tinh vi nữa. x == y là “x bằng y”. x is y là “x chính là y”. Hai tờ $5 giống hệt nhau thì bằng nhau; chỉ một trong hai là tờ tiền trong túi bạn.

y chính là x: một danh sách, hai tên. z là một danh sách khác, tình cờ chứa các giá trị bằng nhau. Đó chính là sự phân biệt mà ví dụ đầu tiên xoay quanh, và is cho bạn thấy nó trực tiếp.

Cách thực sự sao chép một danh sách#

x = [0, 1, 2]
y = x[:]
x[0] = 99
print(x)
print(y)
[99, 1, 2]
[0, 1, 2]

Hãy đọc x[:] thành tiếng là “x, từ đầu, đến cuối”. Đó là một lát cắt (slice) để trống cả hai đầu, nghĩa là mọi phần tử. Phép cắt luôn tạo một danh sách mới, và đó là toàn bộ lý do nó sao chép.

Ba cách nói cùng một điều, cách nào cũng ổn:

Viết làĐọc là
y = x[:]một lát cắt toàn bộ: cách mà môn học của bạn nhiều khả năng sẽ dùng
y = list(x)tạo một danh sách mới từ các phần tử của x
y = x.copy()cách viết tường minh, và dễ đọc thành tiếng nhất

Cùng quy tắc đó bên trong hàm#

Truyền một danh sách vào một hàm (function) cũng không sao chép nó. Tham số (parameter) là thêm một tên nữa cho danh sách của nơi gọi, nên một hàm biến đổi nó sẽ thay đổi bản gốc. Hàm như thế này được gọi là hàm sửa đổi (modifier):

def add_one(alist):
    for i in range(len(alist)):
        alist[i] += 1

nums = [1, 2, 3]
add_one(nums)
print(nums)
[2, 3, 4]

Lưu ý add_one không trả về gì và nơi gọi không gán gì cả, vậy mà nums vẫn thay đổi. Hãy so sánh với một hàm thuần túy (pure), hàm này tạo một danh sách mới và trả lại:

def add_one(alist):
    new_list = []
    for item in alist:
        new_list.append(item + 1)
    return new_list

nums = [1, 2, 3]
result = add_one(nums)
print(nums)
print(result)
[1, 2, 3]
[2, 3, 4]

Cùng tên, cùng lời gọi, tác động ngược nhau lên nums. Không kiểu viết nào sai: hàm thuần túy dễ suy luận hơn vì không có tác dụng phụ ẩn; hàm sửa đổi tránh được việc tạo danh sách thứ hai. Điều quan trọng là biết bạn đã viết loại nào.

Và trường hợp số vẫn hoạt động đúng như trước:

def bump(n):
    n += 1

x = 5
bump(x)
print(x)
5

n += 1 trên một số nguyên sẽ gán lại tên cục bộ (local) n. x của nơi gọi vẫn đứng yên.

Cái bẫy trong cái bẫy

Trên danh sách, += không phải là cách viết tắt của x = x + [...]. Nó mở rộng danh sách tại chỗ, nên bí danh sẽ thấy điều đó:

x = [1, 2]
y = x
x += [3]
print(y)
[1, 2, 3]

Còn dạng viết đầy đủ thì tạo một danh sách mới và gán lại x, để y ở nguyên chỗ cũ:

x = [1, 2]
y = x
x = x + [3]
print(y)
[1, 2]

Các phương thức trả về None#

Sự phân chia khả biến/bất biến còn thể hiện theo một cách nữa, và nó tạo ra một lỗi (bug) trông chẳng giống nguyên nhân của nó chút nào:

mylist = [3, 1, 2]
x = mylist.sort()
print(x)
print(mylist)
None
[1, 2, 3]

.sort() đã sắp xếp danh sách, chỉ là nó không trả danh sách lại. Các phương thức (method) biến đổi danh sách theo quy ước sẽ trả về None, nên gán kết quả của chúng nghĩa là vứt danh sách đi và giữ lấy cái không có gì. Triệu chứng thường xuất hiện vài dòng sau đó, chỉ vào một dòng không phải là chỗ sai:

mylist = [3, 1, 2]
x = mylist.sort()
print(x[0])
Traceback (most recent call last):
  File "sortdemo.py", line 3, in <module>
    print(x[0])
          ~^^^
TypeError: 'NoneType' object is not subscriptable

Có hai dạng đúng, và chúng không thay thế được cho nhau. Sắp xếp tại chỗ và giữ tên ban đầu:

mylist = [3, 1, 2]
mylist.sort()          # sorts in place, changes the original
print(mylist)
[1, 2, 3]

Hoặc tạo một danh sách mới đã sắp xếp và giữ nguyên bản gốc:

mylist = [3, 1, 2]
new = sorted(mylist)   # builds a new list, original untouched
print(mylist)
print(new)
[3, 1, 2]
[1, 2, 3]

Quy tắc “trả về None” này cũng áp dụng cho .reverse(), .append(), .insert(), .extend(), .remove() và .clear(). Những trường hợp không theo quy tắc này đáng biết là .pop(), xóa một phần tử và trả về phần tử đó, cùng .index() và .count(), hoàn toàn không biến đổi danh sách.

Tuple, loại bất biến#

Tuple là một dãy có thứ tự giống danh sách, với một khác biệt giải thích mọi thứ còn lại về nó: bạn không thể thay đổi nó sau khi đã tạo:

point = (3, 4)
point[0] = 5
Traceback (most recent call last):
  File "pt.py", line 2, in <module>
    point[0] = 5
    ~~~~~^^^
TypeError: 'tuple' object does not support item assignment

Vì tuple không thể bị biến đổi, đặt bí danh cho tuple cũng vô hại như đặt bí danh cho một số. Đó là toàn bộ lý do để chọn tuple: nó là một bản ghi bạn có thể chuyền đi khắp nơi mà không lo ai đó thay đổi nó sau lưng bạn.

Tuple cũng là lý do một hàm có vẻ trả về nhiều hơn một giá trị:

def quotient_and_remainder(a, b):
    return a // b, a % b

q, r = quotient_and_remainder(17, 5)
print(q, r)
3 2

Ở đây không có tính năng “trả về nhiều giá trị” đặc biệt nào. return a // b, a % b tạo một tuple, và q, r = giải nén (unpack) nó thành hai tên. Hứng nó vào một biến (variable) duy nhất là bạn có thể thấy rõ tuple:

def quotient_and_remainder(a, b):
    return a // b, a % b

both = quotient_and_remainder(17, 5)
print(both)
print(type(both))
(3, 2)
<class 'tuple'>

Python tính vế phải của phép gán trước, rồi giải nén vào các tên ở vế trái, vì thế hoán đổi không cần biến tạm:

a = [1, 2, 3]
a[0], a[-1] = a[-1], a[0]
print(a)
[3, 2, 1]

Bản sao chỉ sâu một tầng#

Phần này vượt quá những gì đa số bài thi học kỳ đầu hỏi, và nó đáng bỏ ra hai phút vì đây là cùng một ý tưởng ở tầng sâu hơn một bậc. x[:] tạo một danh sách ngoài mới, nhưng lấp đầy nó bằng cùng những đối tượng bên trong:

board = [[0, 0], [0, 0]]
copy = board[:]
copy[0][0] = 9
print(board)
[[9, 0], [0, 0]]

Các danh sách ngoài thực sự tách biệt; hai danh sách bên trong được dùng chung. Đây được gọi là bản sao nông (shallow): nông vì nó chỉ sao chép tầng trên cùng rồi dừng lại. Đó là thứ mà cả ba kỹ thuật sao chép ở trên mang lại cho bạn.

Cùng cơ chế đó tạo ra một lỗi kinh điển với lưới (grid):

row = [0] * 3
grid = [row] * 2
grid[0][0] = 9
print(grid)
[[9, 0, 0], [9, 0, 0]]

[row] * 2 không tạo hai hàng. Nó tạo một hàng, liệt kê hai lần. Hãy tạo lưới bằng một vòng lặp (loop) hoặc comprehension (cú pháp rút gọn), [[0] * 3 for _ in range(2)], để mỗi hàng là một danh sách riêng.

Những chỗ dễ sai#

  • “Sao lưu” một danh sách trước khi thay đổi nó. original = data rồi sửa data sẽ để lại cho bạn hai tên của danh sách đã sửa và hoàn toàn không có bản sao lưu. Hãy dùng original = data[:].
  • Gán kết quả của .sort(). x = mylist.sort() âm thầm đưa None vào x. Không có gì báo lỗi cho đến khi bạn dùng x.
  • Nghĩ rằng hàm sẽ không đụng đến danh sách của bạn. Nếu nó gọi .append() hoặc gán vào alist[i], danh sách của bạn đã thay đổi, ngay cả khi hàm không trả về gì.
  • Nghĩ rằng hàm sẽ thay đổi số của bạn. Đây là hình ảnh phản chiếu của lỗi trên, và cũng phổ biến không kém. Hãy trả về giá trị mới và gán nó.
  • Nhầm lẫn == và is. Hai danh sách riêng biệt có cùng nội dung thì == nhưng không is.
  • Tạo lưới bằng *. [[0] * 3] * 2 cho bạn một hàng được tham chiếu hai lần, và mọi “hàng” thay đổi cùng nhau.
  • Cố biến đổi một tuple hoặc một chuỗi. Cả hai đều báo lỗi TypeError: ... does not support item assignment. Thay vào đó, hãy tạo một cái mới.

Tự kiểm tra trong ứng dụng Kestrel Exams miễn phí

Luyện tập theo chủ đề: dùng được khi không có mạng, không quảng cáo, không cần tài khoản.

Luyện tập chủ đề này →

Câu hỏi thường gặp#

Vì sao sửa x lại làm đổi cả y trong Python?

Vì y = x không sao chép danh sách. Nó đặt cho danh sách duy nhất đang có một cái tên thứ hai. Cả hai tên đều chỉ đến cùng một đối tượng, nên thay đổi thực hiện qua tên này sẽ thấy được qua tên kia. Để có một danh sách độc lập, hãy dùng y = x[:], y = list(x) hoặc y = x.copy().

Vì sao cùng dòng đó không gây vấn đề với số hoặc chuỗi?

Số và chuỗi là bất biến, nên không có cách nào thay đổi chúng tại chỗ. a = 99 không sửa giá trị cũ, nó làm cho a chỉ đến một giá trị khác, và b vẫn chỉ đến giá trị ban đầu. Bí danh vẫn còn đó; chỉ là nó vô hại vì không gì có thể bị biến đổi.

Làm thế nào để sao chép một danh sách trong Python?

Hãy dùng lát cắt toàn bộ y = x[:], hàm tạo danh sách y = list(x), hoặc y = x.copy(). Cả ba đều tạo một danh sách mới. Lưu ý cả ba đều là sao chép nông (shallow): nếu danh sách chứa các danh sách khác, các danh sách bên trong vẫn được dùng chung.

Vì sao danh sách của tôi thành None sau khi sắp xếp?

Vì .sort() sắp xếp danh sách tại chỗ và trả về None, nên x = mylist.sort() lưu None vào x. Hãy gọi mylist.sort() trên một dòng riêng, hoặc dùng new = sorted(mylist), cách này trả về một danh sách mới đã sắp xếp và giữ nguyên bản gốc. Điều tương tự áp dụng cho .reverse(), .append() và .remove().

Sửa một danh sách bên trong hàm có làm đổi danh sách của nơi gọi không?

Có, nếu bạn biến đổi nó. Tham số là một tên khác của cùng danh sách đó, nên nơi gọi sẽ thấy được alist[i] = 0 hoặc alist.append(x). Gán lại tham số bằng alist = [] thì nơi gọi không thấy, và n = n + 1 trên một tham số kiểu số cũng vậy.

Danh sách và tuple khác nhau thế nào?

Tuple là bất biến: một khi đã tạo, bạn không thể đổi một phần tử trong đó. point[0] = 5 báo lỗi TypeError: 'tuple' object does not support item assignment. Điều đó khiến tuple an toàn cho các bản ghi cố định và là lý do việc trả về nhiều giá trị từ một hàm sẽ trả về một tuple.

Đề xuất chỉnh sửa

Có chỗ nào chưa rõ? Có chủ đề nào bạn muốn chúng tôi viết? Hãy cho chúng tôi biết. Chúng tôi đọc mọi tin nhắn, và một lời đề nghị là cách nhanh nhất để có bài hướng dẫn mới: một số bài ở đây ra đời vì có người hỏi.