Cấu trúc điều khiển và cấu trúc dữ liệu

Mệnh đề else gắn vào for sẽ được thực thi khi vòng lặp kết thúc mà không bị break. Vì range(4) không chứa 9 nên break không bao giờ xảy ra, vòng lặp chạy hết rồi mệnh đề else mới chạy, hiển thị done. Sau đó print(n) hiển thị giá trị cuối cùng còn lại trong n tại thời điểm thoát khỏi vòng lặp, tức là 3. Nếu hiểu nhầm thứ tự hiển thị thì sẽ ra dạng 3 hiển thị trước; nếu hiểu nhầm rằng else luôn bị bỏ qua khi vòng lặp kết thúc thì sẽ ra dạng không hiển thị done; nếu bỏ sót việc n vẫn còn giá trị sau khi thoát vòng lặp thì sẽ ra dạng không hiển thị 3.

Ở vòng lặp thứ 1, c là a nên print(c) chạy và hiển thị a. Ở vòng lặp thứ 2, c trở thành b và break cắt đứt vòng lặp. Mệnh đề else của for chỉ được thực thi khi vòng lặp kết thúc mà không bị break, nên ở đây bị bỏ qua và no break không được hiển thị. Nếu nghĩ rằng else luôn chạy khi vòng lặp kết thúc thì sẽ ra dạng hiển thị cả no break; nếu hiểu nhầm rằng print(c) nằm trước break thì sẽ ra dạng hiển thị cả b. Nếu bỏ sót bản thân break thì sẽ ra dạng hiển thị đủ a b c.

Điều kiện để mệnh đề else của for được thực thi là "vòng lặp kết thúc mà không bị break", chứ không phải "đã lặp ít nhất 1 lần". Vì items rỗng nên phần thân không chạy lần nào, nhưng cũng không có break, nên else vẫn được thực thi bình thường và finished được hiển thị. Nếu nghĩ rằng khi rỗng thì else cũng bị bỏ qua sẽ ra dạng không hiển thị gì. Việc truyền một danh sách rỗng cho for tự nó là cách viết hợp lệ nên không gây ra ngoại lệ, cũng không phát sinh TypeError hay StopIteration.

n giảm dần 1 đơn vị từ 5, qua 4, 3 rồi đến khi thành 2 thì break. Mệnh đề else của while cũng giống như for, chỉ được thực thi khi vòng lặp kết thúc mà không bị break, nên ở đây bị bỏ qua và loop ended không được hiển thị. Còn lại chỉ có 2 từ print(n). Nếu nghĩ rằng else luôn chạy sẽ ra dạng hiển thị cả loop ended; nếu bỏ sót break và hiểu nhầm rằng vòng lặp chạy đến khi điều kiện trở thành sai thì n sẽ ra dạng bằng 0.

Khi i là 0, 1, 2 thì cả hai lệnh if đều được vượt qua và append được thực hiện. Khi i là 3, continue hoạt động, phần còn lại của vòng đó, tức là append, bị bỏ qua. Khi i là 4 thì append lại được thực hiện, và khi i là 5 thì break cắt đứt vòng lặp nên append không được thực hiện. Do đó kết quả là [0, 1, 2, 4]. Nếu nghĩ rằng vòng có break cũng được thêm vào thì sẽ ra dạng có cả 5; nếu xử lý continue giống như pass thì sẽ ra dạng còn cả 3.

range(start, stop, step) bắt đầu từ start, tiến từng bước step, và dừng lại trước khi đạt đến stop. Ở đây bắt đầu từ 10, trừ dần 3 nên tiến theo thứ tự 10, 7, 4, 1, và giá trị tiếp theo là -2 vốn nhỏ hơn hoặc bằng 0 nên không được nhận. Vì stop là 0 không được bao gồm, nên không có chuyện 0 nằm ở cuối dãy. Nếu hiểu nhầm rằng start không được bao gồm thì sẽ ra dạng bắt đầu từ 7; nếu hiểu nhầm rằng đếm lùi một bước trước start thì sẽ ra dạng bắt đầu từ 9. Điểm stop không được bao gồm cũng giống như khi bước nhảy dương.

range trả về là một đối tượng kiểu range, tính toán số nguyên cần thiết mỗi khi được yêu cầu rồi trả về. Vì không giữ sẵn toàn bộ phần tử như danh sách nên không tốn nhiều bộ nhớ dù phạm vi lớn. Khi muốn xếp ra để kiểm tra nội dung, cần truyền qua list(). type(range(3)) là range, không phải list hay tuple, và khi hiển thị trực tiếp cũng không ra dạng liệt kê phần tử mà ra range(0, 3). Ngoài ra, vì không phải dùng một lần là hết mà có thể lặp lại bao nhiêu lần cũng được, nên cũng không phải là generator. Lưu ý điểm có thể đọc bằng chỉ số và không thể thay thế phần tử thì giống với tuple, nên chỉ dựa vào tính chất đó thì không thể phân biệt với tuple.

or đánh giá từ trái sang phải và trả về giá trị đầu tiên trở thành đúng (truthy). Vì danh sách rỗng và 0 đều là giá trị sai (falsy), nên "z" ở cuối cùng được trả về. and thì ngược lại, trả về giá trị đầu tiên trở thành sai; 1 là đúng, nhưng đến 0 tiếp theo thì xác định là sai nên 0 được trả về, còn 2 ở bên phải cùng không được đánh giá. Vì giá trị trả về không phải là true/false mà là giá trị tại thời điểm dừng đánh giá, nên không thể ra True hay False. and chỉ trả về 2 ở đầu phải khi tất cả các phần ở giữa đều đúng.

1 < x < 5 có ý nghĩa giống (1 < x) and (x < 5); nếu x là 3 thì cả hai vế đều đúng nên kết quả là True. Toán tử ba ngôi có dạng giá trị khi đúng if điều kiện else giá trị khi sai, và điều kiện ở đây là x % 2, tức là 1. Trong Python, số nguyên khác 0 được xem là đúng (truthy), nên yes được chọn. Nếu hiểu nhầm so sánh chuỗi kết hợp theo hướng từ sau ra trước như 1 < (x < 5), thì x < 5 sẽ là True tức 1, và 1 < 1 cho ra False, dẫn đến đáp án sai. Ngoài ra nếu nghĩ 1 là sai (falsy) thì sẽ chọn nhầm no.

Vì Python biểu diễn khối lệnh bằng thụt lề nên không thể viết một khối lệnh rỗng. Khi định để nội dung của lớp hay hàm viết sau, hoặc khi cố ý không làm gì khi thỏa điều kiện, pass được dùng để lấp vào vị trí đó. Nó không có tác dụng thay đổi luồng xử lý. Việc tiến sang lần lặp kế tiếp là continue, việc cắt đứt vòng lặp là break, việc trả về giá trị cho nơi gọi là return; cả ba đều có vai trò khác với pass.

enumerate lần lượt trả về tuple (số thứ tự, phần tử), và có thể chỉ định giá trị bắt đầu đếm bằng đối số thứ hai start. Ở đây đã truyền 1 nên số thứ tự sẽ là 1, 2, 3. Nếu nhầm lẫn với việc bắt đầu từ 0 khi bỏ qua start thì sẽ ra dạng bắt đầu từ 0. Vì tuple trả về có số thứ tự đứng trước và phần tử đứng sau, nên thứ tự trong print(i, name) cũng theo đúng thứ tự đó, không có chuyện tên đứng trước. Cả 3 phần tử đều được lấy ra nên không dừng lại ở 2 dòng.

zip lấy từng phần tử từ các đối tượng khả lặp được truyền vào để ghép thành cặp, và kết thúc ngay khi đối tượng ngắn nhất hết phần tử. Ở đây danh sách thứ hai chỉ có 2 phần tử nên chỉ tạo được 2 cặp, phần tử dư ra là 3 sẽ bị bỏ qua một cách âm thầm. Không xảy ra lỗi, cũng không có chuyện phần thiếu được lấp bằng 0, hay tạo ra một tuple chỉ có một phần tử. Nội dung của cặp được sắp theo thứ tự đã truyền vào, nên không có chuyện 10 và 1 bị đảo chỗ.

Khi thêm dấu hoa thị, từng cặp trong danh sách được truyền cho zip như các đối số riêng biệt. Nghĩa là tương đương với việc gọi zip((1, 'a'), (2, 'b'), (3, 'c')), các phần tử thứ nhất của mỗi cặp được gom lại với nhau, các phần tử thứ hai cũng vậy, tách thành 2 dãy (1, 2, 3) và ('a', 'b', 'c'). Đây là cách làm thường dùng để đưa dữ liệu đã ghép cặp trở lại thành 2 dãy ban đầu; nếu cho qua zip 2 lần thì trở lại như cũ. Vì trả về là tuple chứ không phải danh sách nên không có dạng dấu ngoặc vuông. Nếu quên dấu hoa thị mà viết zip(pairs), thì bản thân từng cặp được truyền như một đối số duy nhất, cho ra dạng tuple 1 phần tử xếp liền nhau như ((1, 'a'),).

zip(keys, vals) lần lượt trả về tuple (khóa, giá trị), và dict() nhận dãy các cặp đó để tạo ra một từ điển. Vì phần tử thứ nhất của cặp là khóa, phần tử thứ hai là giá trị, nên không thể có dạng số trở thành khóa. Vì đã cho qua dict() nên cũng không còn giữ nguyên dạng danh sách các tuple. Dù cùng hiển thị bằng dấu ngoặc nhọn, nhưng dạng có dấu hai chấm ghép thành cặp là từ điển, còn dạng chỉ xếp các giá trị liền nhau là tập hợp (set).

range(1, 5) trả về 1, 2, 3, 4; giá trị 5 chỉ định làm stop không được bao gồm. Bình phương từng số này sẽ ra 1, 4, 9, 16. Nếu nghĩ rằng range bắt đầu từ 0 thì sẽ ra dạng bắt đầu từ 0; nếu hiểu nhầm rằng stop được bao gồm thì sẽ ra dạng có cả 25. Nếu đọc nhầm n * n thành n * 2 thì sẽ ra dạng tăng dần 2 đơn vị một. Nên rèn cách đọc rằng list comprehension đánh giá biểu thức ở đầu bên trái cho từng phần tử, rồi tạo ra một danh sách mới gồm các kết quả đó.

Cú pháp comprehension có dấu hai chấm bên trong dấu ngoặc nhọn là dict comprehension, phía trái dấu hai chấm là khóa, phía phải là giá trị. Ở đây tạo ra từ điển lấy từ (word) làm khóa, số ký tự của từ đó làm giá trị. Nếu đọc ngược khóa và giá trị thì sẽ ra dạng số ký tự trở thành khóa. Nếu bao bằng dấu ngoặc vuông thì sẽ thành danh sách các tuple, nhưng ở đây là dấu ngoặc nhọn nên không như vậy. Nếu không có dấu hai chấm thì trở thành set comprehension, chỉ hiển thị các giá trị xếp liền nhau, nhưng vì có dấu hai chấm nên chỉ có thể tạo ra một từ điển.

Python không có cú pháp gọi là tuple comprehension, và dạng bao bằng dấu ngoặc tròn như thế này trở thành biểu thức generator (generator expression). Kiểu là generator, không tạo trước toàn bộ giá trị mà tính từng cái một khi được yêu cầu nên tiết kiệm bộ nhớ, nhưng vì là iterator nên dùng một lần là hết. Khi muốn có tuple thì cần bọc bằng tuple(). Nếu viết bằng dấu ngoặc vuông thì trở thành list comprehension cho ra list; nếu gán trực tiếp range(3) thì ra range. Không thể có được tuple bằng cách viết như thế này.

Số dư khi chia từng giá trị của range(10) cho 4 lần lượt là 0, 1, 2, 3, 0, 1, 2, 3, 0, 1. Cú pháp comprehension dùng dấu ngoặc nhọn nhưng không có dấu hai chấm là set comprehension, nên các giá trị trùng nhau được gộp lại thành một, chỉ còn lại 4 loại là 0, 1, 2, 3. Nếu bỏ sót việc trùng lặp bị loại bỏ mà đếm nguyên số lượng giá trị thì sẽ ra 10. Nếu bỏ sót việc có chứa số dư 0 mà chỉ đếm 3 loại 1, 2, 3 thì sẽ ra 3. Giá trị 0 là kết quả của việc hiểu nhầm rằng comprehension không tạo ra gì cả, nhưng chừng nào còn lặp qua range(10) thì nội dung không thể rỗng được. Vì thứ tự hiển thị của set không cố định, nên kiểm tra bằng số phần tử là cách chắc chắn nhất.

Khi xếp 2 câu lệnh for trong comprehension, câu lệnh for viết bên trái sẽ trở thành vòng lặp ngoài. Thứ tự này hoàn toàn giống như khi viết lồng câu lệnh for thông thường: cố định x là 1 rồi cho y chạy qua a, b, sau đó chuyển x thành 2 và lặp lại y tương tự. Nếu đọc nhầm rằng for bên phải là vòng ngoài thì sẽ ra thứ tự x chạy trước. Nội dung của cặp theo đúng thứ tự (x, y) đã viết trong biểu thức, nên không có chuyện ký tự đứng trước.

Đối số thứ hai start của enumerate chỉ quyết định số thứ tự được gắn bắt đầu từ đâu. Giá trị mặc định là 0, nên nếu truyền 1 thì sẽ có số thứ tự quen thuộc với con người. Chỉ có cách đánh số thay đổi, còn phạm vi hay số lượng phần tử được lấy ra không đổi, đây là điểm mấu chốt. Nó không có tác dụng giới hạn số lượng hay bỏ cách phần tử, cũng không phải là thứ dịch chuyển vị trí bắt đầu lấy ra. Những chức năng này đều thuộc về các công cụ khác như slice.

sort là phương thức sắp xếp lại danh sách tại chỗ, giá trị trả về là None. Do đó result nhận giá trị None, còn kết quả sắp xếp nằm ở phía nums. Nếu nghĩ rằng một danh sách mới đã sắp xếp được trả về thì sẽ ra dạng result chứa danh sách. Nếu bỏ sót việc sort làm thay đổi danh sách gốc thì sẽ ra dạng nums vẫn giữ thứ tự ban đầu. Khi muốn có một danh sách đã sắp xếp mà vẫn giữ nguyên bản gốc, cần dùng hàm dựng sẵn sorted.

sort là phương thức của danh sách, sắp xếp lại chính danh sách đó và trả về None. sorted là hàm dựng sẵn, hoàn toàn không thay đổi thứ tự ban đầu mà trả về một danh sách mới đã sắp xếp. Việc chọn dùng cái nào tùy vào có muốn giữ lại bản gốc hay không. Nếu nhớ nhầm vai trò của hai bên thì sẽ ra giải thích sort trả về danh sách mới. Nếu nghĩ tính phá hủy (destructive) nghiêng về một phía duy nhất thì sẽ ra giải thích cả hai đều sắp xếp tại chỗ, hoặc cả hai đều không thay đổi bản gốc. Ngoài ra sorted cũng có thể nhận các đối tượng khả lặp khác ngoài danh sách, và kết quả luôn là một danh sách.

append thêm toàn bộ đối số như một phần tử duy nhất vào cuối, nên nếu truyền vào một danh sách thì sẽ trở thành lồng nhau và độ dài chỉ tăng thêm 1. extend thêm từng giá trị được lấy ra tuần tự từ đối số, nên nội dung được tháo ra và độ dài tăng thêm 2. Nếu đảo vai trò của hai phương thức thì kết quả của a và b sẽ ngược lại. Nếu nghĩ cả hai có cùng chức năng thì sẽ ra dạng cả hai đều lồng nhau, hoặc cả hai đều phẳng. Cả hai phương thức đều trả về None, nên cũng cần nhớ không được nhận kết quả bằng một biến.

Việc nhân bản bằng slice là sao chép nông (shallow copy): danh sách ngoài được tạo mới, nhưng các phần tử bên trong vẫn dùng chung với bản gốc. copy1[0] và orig[0] cùng trỏ đến một danh sách, nên khi append vào đó thì phía bản gốc cũng thấy thay đổi. Nếu nghĩ rằng đã tách rời hoàn toàn thì sẽ ra dạng bản gốc không đổi. Vì chỉ ghi đè danh sách bên trong ở đầu tiên nên không lan sang các phần tử phía sau, và cũng không phải là thêm vào danh sách ngoài nên số 9 không xuất hiện xếp ở ngoài. Muốn tách rời cả phần bên trong thì cần dùng copy.deepcopy.

copy.deepcopy nhân bản cả nội dung bên trong lồng nhau, nên d[0] là một danh sách khác với base[0], việc append vào đó không ảnh hưởng đến base. Trong khi đó s là sao chép nông nên s[1] và base[1] cùng là một danh sách, việc append vào đó cũng được thấy ở base. Do đó chỉ phần tử phía sau bị kéo dài thêm. Nếu nghĩ cả hai đều ảnh hưởng thì sẽ ra dạng cả hai phần tử bên trong đều dài thêm; nếu nghĩ cả hai đều không ảnh hưởng thì sẽ ra dạng giữ nguyên như ban đầu. Nếu nhầm lẫn sao chép sâu với sao chép nông thì sẽ ra dạng chỉ phần tử phía trước dài thêm.

Phép nhân ở lớp ngoài không tạo ra các hàng mới, mà chỉ xếp 2 tham chiếu cùng trỏ đến một danh sách duy nhất. grid[0] và grid[1] là cùng một thực thể, nên khi ghi đè vị trí chỉ số 1 của một bên thì bên kia cũng bị thay đổi ở đúng vị trí đó. Nếu nghĩ các hàng độc lập với nhau thì sẽ ra dạng chỉ một hàng thay đổi. Vì đã ghi đè vào vị trí chỉ số 1 nên cũng không thể ra dạng phần đầu trở thành 5. Muốn các hàng độc lập với nhau thì cần viết [[0] * 3 for _ in range(2)].

Quyết định tuple hay không là dấu phẩy, chứ không phải dấu ngoặc tròn. (7) chỉ là số nguyên được bao trong ngoặc thể hiện thứ tự ưu tiên tính toán nên kiểu là int; phải viết (7,) có dấu phẩy ở cuối thì mới trở thành tuple có 1 phần tử. Nếu nghĩ rằng cứ bao bằng ngoặc là thành tuple thì sẽ ra dạng cả hai đều là tuple; nếu nhầm lẫn hai cái với nhau thì sẽ ra dạng thứ tự ngược lại hoặc cả hai đều là int. Riêng tuple rỗng là ngoại lệ, được viết là () không có dấu phẩy.

Điều mà tuple đóng băng là sự tương ứng chỉ đến phần tử nào, chứ không đóng băng luôn nội dung mà nó trỏ tới. t[1] là một danh sách, và bản thân danh sách đó là khả biến (mutable) nên có thể append được. Cách viết gán trực tiếp vào phần tử của tuple như t[1] = [] mới gây ra TypeError, nhưng ở đây không phải là thay thế phần tử. Vì thêm vào bên trong danh sách nên độ dài của tuple sẽ không tăng, và cũng không thể giữ nguyên hoàn toàn không đổi.

Gán vào slice là thao tác thay thế toàn bộ phạm vi đã chỉ định bằng nội dung của vế phải. x[1:3] trỏ đến 2 phần tử là 2 và 3, chúng bị thay bằng 1 phần tử duy nhất là 9, nên tổng độ dài giảm từ 5 xuống 4. Nếu nghĩ chỉ 1 phần tử được thay thế thì sẽ ra dạng độ dài vẫn là 5; nếu nghĩ vế phải sẽ được kéo dài cho khớp với bề rộng thì sẽ ra dạng có 2 số 9 xếp cạnh nhau. Nếu đọc lệch điểm bắt đầu của phạm vi đi một vị trí thì sẽ ra dạng còn giữ lại số 2. Đặc điểm của việc gán vào slice là bề rộng bên trái và độ dài bên phải có thể khác nhau.

y[1:1] là phạm vi có bề rộng 0, nên việc gán vào đó là chèn thêm mà không xóa bớt, danh sách trở thành [1, 7, 8, 2, 3]. Tiếp theo del y[0] xóa số 1 ở đầu, còn lại [7, 8, 2, 3]. Nếu đọc nhầm rằng khi chèn thì phần tử gốc cũng mất đi 1 cái thì sẽ ra dạng 7 8 3; nếu nghĩ del xóa ở vị trí khác thì sẽ ra dạng còn giữ số 1 ở đầu. Nếu đọc nhầm rằng đã thêm vào cuối thì sẽ ra dạng 2 và 3 đứng trước. Cũng cần nắm rằng del là câu lệnh nên không có giá trị trả về, và xóa mà không lấy giá trị ra.

get không ném ra ngoại lệ khi không có khóa; nếu bỏ qua đối số thứ hai thì trả về None, nếu có truyền thì trả về giá trị đó. Do đó lệnh đầu là None, lệnh thứ hai là 0. Nếu nghĩ rằng khi không có đối số thứ hai vẫn trả về 0 thì sẽ ra dạng cả hai đều là 0; nếu nghĩ đối số thứ hai bị bỏ qua thì sẽ ra dạng cả hai đều là None. Viết bằng dấu ngoặc vuông như d["z"] sẽ gây ra KeyError, và get chính là công cụ để tránh điều đó.

setdefault chỉ trả về giá trị hiện có nếu khóa đã tồn tại, và không thay đổi từ điển. Nếu khóa chưa có thì chèn đối số thứ hai làm giá trị và trả về giá trị đó. Vì vậy lần gọi thứ nhất trả về giá trị 1 sẵn có và từ điển giữ nguyên, lần gọi thứ hai chèn thêm 99 và trả về 99. Nếu nghĩ rằng giá trị đã có cũng bị ghi đè thì sẽ ra dạng cả hai đều là 99. Nếu nghĩ việc chèn không xảy ra thì sẽ ra dạng từ điển không tăng thêm. Nếu bỏ qua đối số thứ hai thì giá trị được chèn sẽ là None, nên dạng có None là kết quả khi không viết đối số thứ hai.

in đối với từ điển chỉ kiểm tra khóa. "x" có trong khóa nên là True, còn 1 tuy tồn tại như một giá trị nhưng không có trong khóa nên là False. Khi muốn kiểm tra giá trị thì nhắm vào d.values(), trường hợp này sẽ là True. Nếu nghĩ rằng in cũng xét cả giá trị thì sẽ ra dạng tất cả đều True; nếu nghĩ ngay cả nhắm vào values() cũng không xét giá trị thì sẽ ra dạng phần cuối là False. Nếu đọc hoán đổi vai trò của khóa và giá trị thì sẽ ra dạng phần đầu là False. Cách dùng tiêu chuẩn là kiểm tra sự tồn tại của khóa trước rồi mới tra bằng dấu ngoặc vuông.

Literal của từ điển tạo từng mục theo thứ tự từ trái sang, nên nếu cùng một khóa xuất hiện 2 lần thì giá trị sau sẽ ghi đè giá trị trước. Không xảy ra lỗi hay cảnh báo. Nếu nghĩ giá trị viết trước sẽ được giữ lại thì sẽ ra dạng giá trị của a vẫn là 1. Ngoài ra, từ điển giữ nguyên thứ tự đã chèn vào, việc ghi đè không làm thay đổi vị trí, nên a vẫn đứng ở vị trí đầu như cũ. Do đó không có chuyện thứ tự các khóa bị đảo lộn, cũng không có chuyện giá trị của b bị ảnh hưởng theo.

dict có thể tạo từ điển từ đối số từ khóa, cũng như từ một dãy các cặp (khóa, giá trị). Dù dùng cách viết nào thì cũng tạo ra từ điển có cùng nội dung nên phép so sánh cho ra True. Nếu nghĩ cách tạo khác nhau sẽ ra vật khác nhau thì sẽ ra dạng phép so sánh là False. Vì tên của đối số từ khóa trở thành trực tiếp chuỗi làm khóa, nên không có chuyện khóa và giá trị bị đảo chỗ. Vì đã cho qua dict nên đã trở thành từ điển, không còn giữ nguyên dạng dãy các cặp.

{1, 2} có chứa phần tử sẽ trở thành tập hợp (set), nhưng nếu bên trong rỗng thì không thể quyết định là từ điển hay tập hợp. Python xử lý trường hợp này như một từ điển, nên {} là một từ điển rỗng. Khi muốn có một tập hợp rỗng thì buộc phải viết set(). Nếu nghĩ rằng dấu ngoặc nhọn luôn luôn là tập hợp thì sẽ ra dạng cả hai đều là set; nếu nhầm lẫn hai cái với nhau thì sẽ ra dạng thứ tự ngược lại. Nếu nghĩ đến cả set() cũng trở thành từ điển thì sẽ ra dạng cả hai đều là dict. Vì cả tập hợp và từ điển đều dùng dấu ngoặc nhọn nên sự phân biệt này rất dễ nhầm lẫn.

Dấu và (&) là phép giao, giữ lại 3 và 4 vốn có ở cả hai. Dấu mũ (^) là phép hiệu đối xứng, gom các phần tử chỉ có ở một bên duy nhất, nên giữ lại 1 và 2 chỉ có ở s1, và 5 chỉ có ở s2, còn 3 và 4 chung thì bị loại. Nếu nhầm hiệu đối xứng với phép hiệu (difference) thì sẽ ra dạng thiếu số 5; nếu đảo thứ tự 2 phép toán thì thứ tự hiển thị sẽ ngược lại. Nếu nhầm hiệu đối xứng với phép hợp (union) thì sẽ ra dạng có cả 3 và 4. Vì thứ tự hiển thị của tập hợp không cố định nên ở đây dùng sorted để sắp xếp rồi kiểm tra.

Khi truyền một danh sách cho set, các phần tử trùng lặp bị loại bỏ, chỉ còn lại 3 loại giá trị là 1, 2, 3, nên độ dài là 3. Khi truyền một tập hợp cho sorted thì trả về một danh sách mới đã sắp theo thứ tự tăng dần. Nếu nghĩ phần trùng lặp vẫn còn thì sẽ ra dạng số lượng là 6. sorted sắp xếp theo giá trị lớn nhỏ chứ không theo thứ tự xuất hiện gốc, nên cũng không thể xếp theo thứ tự xuất hiện đầu tiên. Thứ tự hiển thị của bản thân tập hợp không có ý nghĩa, nên khi muốn sắp xếp cần cho qua sorted.

Phần tử của tập hợp và khóa của từ điển phải là loại có thể băm (hashable). Tuple không thể thay đổi nội dung nên có thể băm và thêm được, nhưng danh sách có thể thay đổi nội dung về sau nên không thể băm, dẫn đến TypeError với thông báo unhashable type. Nếu nghĩ cả hai đều thêm được thì sẽ ra dạng hiển thị 2; nếu nghĩ danh sách được ngầm chuyển thành tuple thì sẽ ra dạng hiển thị 1. Việc trộn lẫn kiểu tự nó không phải là vấn đề, nên cách giải thích dẫn đến ValueError cũng sai.

keys chỉ trả về khóa, values chỉ trả về giá trị, còn items lần lượt trả về tuple (khóa, giá trị). Khi duyệt qua từ điển, cách viết chuẩn là for k, v in d.items() nhận bằng 2 biến. Nếu nhớ nhầm và đảo vai trò của 3 phương thức thì sẽ ra giải thích kiểu keys trả về giá trị. Những gì items trả về là một dãy các mục chứ không phải số lượng, nên giải thích rằng nó trả về số lượng mục cũng sai; khi muốn biết số lượng thì dùng len. Ngoài ra, nếu truyền trực tiếp từ điển cho for thì các khóa sẽ được lấy ra.