Green

LECTURE 06
2D ARRAY
TUPLE, SET, DICTIONARY
Big-O Coding

Website: www.bigocoding.com

1
 Green

Mảng 2 chiều là gì?

• Mảng 2 chiều / ma trận (2-dimensional array /
matrix) là cấu trúc dữ liệu dùng để biểu diễn các
đối tượng dữ liệu ở dạng nhiều dãy khác nhau,
được chia thành nhiều dòng và nhiều cột.

2
 Green

Ứng dụng mảng 2 chiều

3
 Green

Hình ảnh mảng 2 chiều

• Mảng 2 chiều có 3 dòng và 4 cột.

Chỉ số cột (n)

0 1 2 3
Chỉ số dòng (m) 0 4 18 9 3
1 12 45 74 15
2 84 87 75 67

4
 Green

Tạo mảng 2 chiều

• Trong Python, để tạo mảng 2 chiều nói riêng, mảng
n chiều nói chung, ta sử dụng nested list.

5
 Green

VD: Tạo mảng 2 chiều các số nguyên (C1)

lst1 = [1, 2, 3, 4]
lst2 = [5, 6, 7, 8]
lst3 = [9, 10, 11, 12]

# A 2D array with 3 rows and 4 columns

lst = [lst1, lst2, lst3]

0 1 2 3
0 1 2 3 4
1 5 6 7 8
2 9 10 11 12

6
 Green

VD: Tạo mảng 2 chiều các số nguyên (C1)

lst1 = [1, 2, 3, 4]
lst2 = [5, 6, 7, 8]
lst3 = [9, 10, 11, 12]

# A 2D array with 3 rows and 4 columns

lst = []
lst.append(lst1)
lst.append(lst2)
lst.append(lst3)

0 1 2 3
0 1 2 3 4
1 5 6 7 8
2 9 10 11 12

7
 Green

Truy xuất 1 phần tử trong mảng

• Sử dụng toán tử [i][j] để truy xuất 1 phần tử trong
mảng.

• Trong đó, nếu mảng có m dòng, n cột:

• i: chỉ số dòng, bắt đầu từ 0, kết thúc là m-1.

• j: chỉ số cột, bắt đầu từ 0, kết thúc là n-1.

• Mảng có m dòng, n cột sẽ có m*n phần tử.

8
 Green

VD1: Index hợp lệ

lst1 = [10, 20, 30, 40]
lst2 = [50, 60, 70, 80]
lst3 = [90, 100, 110, 120]
# A 2D array with 3 rows and 4 columns
lst = [lst1, lst2, lst3]

print(lst[0][0])
print(lst[2][1])
print(lst[2][3])

10
100
120

9
 Green

VD2: Index out of range

lst1 = [10, 20, 30, 40]
lst2 = [50, 60, 70, 80]
lst3 = [90, 100, 110, 120]
# A 2D array with 3 rows and 4 columns
lst = [lst1, lst2, lst3]

print(lst[3][0])
print(lst[2][10])
print(lst[4][7])

IndexError: list index out of range

IndexError: list index out of range
IndexError: list index out of range

10
 Green

VD3: Index là số âm
lst1 = [10, 20, 30, 40]
lst2 = [50, 60, 70, 80]
lst3 = [90, 100, 110, 120]
# A 2D array with 3 rows and 4 columns
lst = [lst1, lst2, lst3]

print(lst[-1][0])
print(lst[2][-2])
print(lst[-1][-3])

90
110
100

11
 Green

2 cách duyệt các phần tử trong mảng

1. Duyệt theo index, sử dụng 2 vòng lặp for in
range().

2. Duyệt theo phần tử, sử dụng 2 vòng lặp for x in

lst.

12
 Green

VD1: Duyệt theo index

lst1 = [10, 20, 30, 40]
lst2 = [50, 60, 70, 80]
lst3 = [90, 100, 110, 120]
# A 2D array with 3 rows and 4 columns
lst = [lst1, lst2, lst3]

for i in range(len(lst)):
for j in range(len(lst[i])):
print(lst[i][j], end=" ")
print()

10 20 30 40
50 60 70 80
90 100 110 120

# len(lst): số dòng của mảng 2 chiều lst = 3

# len(lst[i]): số phần tử trong dòng thứ i = số cột
trong mảng 2 chiều lst = 4. 13
 Green

VD2: Duyệt theo phần tử

lst1 = [10, 20, 30, 40]
lst2 = [50, 60, 70, 80]
lst3 = [90, 100, 110, 120]
# A 2D array with 3 rows and 4 columns
lst = [lst1, lst2, lst3]

for tempList in lst:

for x in tempList:
print(x, end=" ")
print()

10 20 30 40
50 60 70 80
90 100 110 120

# tempList lần lượt sẽ là lst1, lst2, lst3, hay chính

là từng dòng trong mảng 2 chiều lst.
14
 Green

BT1 – TÍNH TỔNG CÁC DÒNG

• Viết chương trình tính tổng của từng dòng trong
ma trận số nguyên.

15
 Green

Kĩ thuật xử lí trên từng dòng

• Đây là kĩ thuật dùng để tìm dòng hoặc tìm giá trị thuộc
dòng nào đó thỏa mãn điều kiện cho trước.

• Khi xử lí trên dòng, tức là đã xác định trên dòng nào,

do đó, chỉ cần duyệt các phần tử trên dòng đó.

0 1 2 3
0 4 18 9 3
1 12 45 74 15
2 84 87 75 67

16
 Green

BT1 – Gợi ý – Đọc mảng 2 chiều

17
 Green

BT1 – Gợi ý – Đọc mảng 2 chiều

1. Khởi tạo mảng rỗng a.

2. Đọc m (số dòng) và n (số cột).

3. Sử dụng vòng lặp for in range, duyệt theo số

dòng m.
a. Đọc giá trị dòng i lên mảng tmp. (tương tự thao tác
đọc mảng 1 chiều ở bài 05)
b. append mảng 1 chiều tmp vào mảng 2 chiều a.
(tham khảo slide 7)

18
 Green

BT1 – Gợi ý – Đọc mảng 2 chiều

• Dữ liệu đầu vào • Xử lí từng bước
3 4 m = 3
1 2 3 4 n = 4
5 6 7 8 a = []
9 10 11 12
tmp = [1, 2, 3, 4]
a = [[1, 2, 3, 4]] # append tmp vào a

tmp = [5, 6, 7, 8]
a = [[1, 2, 3, 4],
[5, 6, 7, 8]] # append tmp vào a

tmp = [9, 10, 11, 12]

a = [[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12]] # append tmp vào a
19
 Green

BT1 – Gợi ý – Tính tổng từng dòng

20
 Green

BT1 – Gợi ý – Tính tổng từng dòng

1. Sử dụng vòng lặp for in range, duyệt theo số
dòng m.
• Sử dụng kĩ thuật tính tổng mảng 1 chiều ở bài 05, để
tính tổng của mảng a[i].

a. Khởi tạo: sum = 0.

b. Sử dụng vòng lặp for in range, duyệt theo số cột n.

a. sum += a[i][j].

c. In tổng dòng i ra màn hình.

21
 Green

BT1 – Minh họa – Tính tổng từng dòng

0 1 2 3 i = 0 # tính tổng của dòng 0
sum = 0
0 4 18 9 3 j = 0, sum += a[0][0] = 0 + 4 = 4
1 12 45 74 15 j = 1, sum += a[0][1] = 4 + 18 = 22
2 84 87 75 67 j = 2, sum += a[0][2] = 22 + 9 = 31
j = 3, sum += a[0][3] = 31 + 3 = 34
In theo format 0: 34

i = 1 # tính tổng của dòng 1

sum = 0
j = 0, sum += a[1][0] = 0 + 12 = 12
j = 1, sum += a[1][1] = 12 + 45 = 57
j = 2, sum += a[1][2] = 57 + 74 = 131
j = 3, sum += a[1][3] = 131 + 15 = 146
In theo format 1: 146

22
 Green

BT1 – Minh họa – Tính tổng từng dòng

0 1 2 3 i = 2 # tính tổng của dòng 2
sum = 0
0 4 18 9 3
j = 0, sum += a[2][0] = 0 + 84 = 84
1 12 45 74 15 j = 1, sum += a[2][1] = 84 + 87 = 171
2 84 87 75 67 j = 2, sum += a[2][2] = 171 + 75 = 246
j = 3, sum += a[2][3] = 246 + 67 = 313
In theo format 2: 313

23
 Green

BT1 – Lời giải

a = []
m, n = map(int, input().split())
for i in range(m):
tmp = list(map(int, input().split()))
a.append(tmp)

for i in range(m):
sum = 0
for j in range(n):
sum += a[i][j]
print("{0}: {1}".format(i, sum))

24
 Green

BT2 – CỘT TOÀN ÂM

• Viết chương trình liệt kê các cột toàn âm của ma
trận các số nguyên.

25
 Green

Kĩ thuật xử lí trên từng cột

• Đây là kĩ thuật dùng để tìm cột hoặc tìm giá trị thuộc
cột nào đó thỏa mãn điều kiện cho trước.

• Khi xử lí trên cột, tức là đã xác định trên cột nào, do

đó, chỉ cần duyệt các các phần tử trên cột đó.

0 1 2 3
0 4 18 9 3
1 12 45 74 15
2 84 87 75 67

26
 Green

BT2 – Gợi ý – Liệt kê cột toàn âm

1. Dùng vòng lặp for in range, duyệt theo số cột.
a. Gọi hàm isAllNegatives() kiểm tra cột j có toàn
âm không.

27
 Green

BT2 – Gợi ý –
Kiểm tra cột col có toàn âm

28
 Green

BT2 – Gợi ý – Hàm isAllNegatives()

• Đầu vào: mảng 2 chiều a, số dòng m, số cột n, cột
cần kiểm tra col.

• Đầu ra: Boolean (True/False).

• Xử lí: sử dụng kĩ thuật đặt cờ hiệu

1. flag = True

2. Duyệt theo m, qua các phần tử trong cột

a. Nếu a[i][col] >= 0, flag = False

29
 Green

BT2 – Minh họa – Hàm isAllNegatives()

0 1 2 3
0 4 18 -9 3
1 -7 -2 -4 -1
2 -8 87 -5 67

j = 0, Hàm isAllNegatives(a, m, n, j) = False,

nghĩa là cột 0 ko toàn âm, nên ko in 0 ra.

j = 1, Hàm isAllNegatives(a, m, n, j) = False,

nghĩa là cột 1 ko toàn âm, nên ko in 1 ra.

j = 2, Hàm isAllNegatives(a, m, n, j) = True,

nghĩa là cột 2 toàn âm, nên in 2 ra.

j = 3, Hàm isAllNegatives(a, m, n, j) = False,

nghĩa là cột 3 ko toàn âm, nên ko in 3 ra.
30
 Green

BT2 – Minh họa – Tại sao biết cột 0 ko toàn âm

• Sử dụng kĩ thuật đặt cờ hiệu

0 1 2 3
0 4 18 -9 3
1 -7 -2 -4 -1
2 -8 87 -5 67

# tin tưởng rằng cột 0 toàn âm

flag = True

i = 0, a[0][0] = 4 >= 0? (Yes), flag = False

i = 1, a[1][0] = -7 >= 0? (No)
i = 2, a[2][0] = -8 >= 0? (No)
Kết quả: flag = False

31
 Green

BT2 – Minh họa – Tại sao biết cột 2 toàn âm

• Sử dụng kĩ thuật đặt cờ hiệu

0 1 2 3
0 4 18 -9 3
1 -7 -2 -4 -1
2 -8 87 -5 67

# tin tưởng rằng cột 0 toàn âm

flag = True

i = 0, a[0][1] = -9 >= 0? (No)

i = 1, a[1][2] = -4 >= 0? (No)
i = 2, a[2][3] = -5 >= 0? (No)
Kết quả: flag = True

32
 Green

BT2 – Lời giải

def isAllNegatives(a, m, n, col):
flag = True
for i in range(m):
if(a[i][col] >= 0):
flag = False
return flag

for j in range(n):
if isAllNegatives(a, m, n, j):
for i in range(m):
print(j, end = ' ')

33
 Green

BT3 – ĐẾM NGUYÊN TỐ TRÊN BIÊN

• Đếm xem trên biên của ma trận có bao nhiêu phần
tử là số nguyên tố.

34
 Green

Kĩ thuật xử lí trên đường biên

• Đây là kĩ thuật dùng để xử lý các giá trị thuộc phía viền
bên ngoài của ma trận.

• Cách làm:
• Dùng 1 vòng lặp, xử lí trên dòng 0 và dòng cuối (m-1)

• Dùng 1 vòng lặp, xử lí trên cột 0 và cột cuối (n-1).

• Cẩn thận, đừng xử lí lặp lại 2 lần các giá trị ở 4 góc.
0 1 2 3
0 4 18 -9 3
1 -7 -2 -4 -1
2 -8 87 -5 67
35
 Green

BT3 – Gợi ý –
Đếm số nguyên tố trên đường biên

Xử lí cột 0
và cột n-1

Xử lí dòng 0
và dòng m-1

36
 Green

BT3 – Gợi ý – Hàm countPrimes()

• Đầu vào: mảng 2 chiều a, số dòng m, số cột n.

• Đầu ra: tổng các phần tử trên 4 đường biên.

• Xử lí:
1. Duyệt theo số dòng m, đếm các số nguyên tố ở
cột 0 và cột n-1.

2. Duyệt theo số cột n, đếm các số nguyên tố ở dòng

0 và dòng m-1.

37
 Green

BT3 – Minh họa –

Đếm số nguyên tố trên đường biên
0 1 2 3
0 4 18 -9 3
1 -7 -2 -4 -1
2 -8 87 -5 67

cnt = 0
# Vòng lặp 1: xét dòng 0 và dòng m-1
j = 0
a[0][0] = 4, isPrime? (No)
a[2][0] = -8, isPrime? (No)
j = 1
a[0][1] = 18, isPrime? (No)
a[2][1] = 87, isPrime? (No)
j = 2
a[0][2] = -9, isPrime? (No)
a[2][2] = -5, isPrime? (No)
j = 3
a[0][3] = 3, isPrime? (Yes), cnt = 1
a[2][3] = 67, isPrime? (Yes), cnt = 2 38
 Green

BT3 – Minh họa –

Đếm số nguyên tố trên đường biên
0 1 2 3
0 4 18 -9 3
1 -7 -2 -4 -1
2 -8 87 -5 67

# Vòng lặp 2: xét cột 0 và cột n-1

# ko xét i = 0 vì a[0][0], a[0][3] đã xét ở trên
i = 1
a[1][0] = -7, isPrime? (No)
a[1][3] = -1, isPrime? (No)
# ko xét i = 2 vì a[2][0], a[2][3] đã xét ở trên

Kết quả: cnt = 2

39
 Green

BT3 – Lời giải

def countPrimes(a, m, n):
cnt = 0
for i in range(m):
cnt += isPrime(a[i][0]) + isPrime(a[i][n-1])
for j in range(1, n - 1):
cnt += isPrime(a[0][j]) + isPrime(a[m-1][j])
return cnt

40
 Green

BT4 – SỐ NGUYÊN TỐ TRÊN ĐƯỜNG CHÉO CHÍNH

• Viết chương trình đếm xem trên đường chéo chính

của ma trận những số nào là số nguyên tố.

41
 Green

Kĩ thuật xử lí trên đường chéo chính

• Khi ma trận có số dòng và số cột bằng nhau thì ta
gọi đó là ma trận vuông.

• Ma trận vuông sẽ có 2 loại đường chéo như sau:

• Đường chéo chính.

• Đường chéo phụ.

42
 Green

Đường chéo trong ma trận vuông

Đường chéo chính Đường chéo phụ

43
 Green

BT4 – Gợi ý –
Đếm số nguyên tố trên đường chéo chính

44
 Green

BT4 – Gợi ý – Hàm countPrimes()

• Đầu vào: mảng 2 chiều a, số dòng = số cột = n.

• Đầu ra: số lượng số hoàn hảo trong mảng.

• Xử lí:
1. Dùng vòng lặp for in range, duyệt qua các phần tử
[i][i] trong mảng để đếm số nguyên tố.

45
 Green

BT4 – Minh họa – Hàm countPrimes()

0 1 2 3
0 2 18 -9 3
1 -7 6 -4 -1
2 -8 87 7 67
3 7 2 1 56

cnt = 0
i = 0, a[0][0] = 2, isPrime? (Yes), cnt = 1
i = 1, a[1][1] = 6, isPrime? (No)
i = 2, a[2][2] = 7, isPrime? (Yes), cnt = 2
i = 3, a[3][3] = 6, isPrime? (No)

Kết quả: cnt = 2

46
 Green

BT4 – Lời giải

def countPrimes(a, n):
cnt = 0
for i in range(n):
cnt += isPrime(a[i][i])
return cnt

47
 Green

BT5 – TÍCH SỐ NGUYÊN TỐ TRÊN ĐƯỜNG CHÉO PHỤ

• Viết chương trình tính tích các số nguyên tố trên

đường chéo phụ của ma trận vuông các số
nguyên.

48
 Green

BT5 – Gợi ý –
Tích số nguyên tố trên đường chéo phụ

49
 Green

BT5 – Gợi ý – Hàm mulPrimes()

• Đầu vào: mảng 2 chiều a, số dòng = số cột = n.

• Đầu ra: tích các số chính phương trong mảng.

• Xử lí:
1. Dùng vòng lặp for in range, duyệt qua các phần tử
[i][n-i-1] trong mảng để tính tích.

50
 Green

BT5 – Minh họa – Hàm mulPrimes()

0 1 2 3
0 4 18 -9 3
1 -7 6 4 -1
2 -8 17 8 67
3 9 2 1 56

ans = 1
i = 0, a[0][3] = 3, isPrime? (Yes), ans = 1 * 3 = 3
i = 1, a[1][2] = 4, isPrime? (No)
i = 2, a[2][1] = 17, isPrime? (Yes), cnt = 3 * 17 = 51
i = 3, a[3][0] = 9, isPrime? (No)

Kết quả: ans = 51

51
 Green

BT5 – Lời giải

def mulPrimes(a, n):
ans = 1
for i in range(n):
if isPrime(a[i][n - i - 1]):
ans = (ans * a[i][n - i - 1]) % 1000003
return ans

52
 Green

Một số cấu trúc dữ liệu dạng

danh sách khác

53
 Green

Tuple
• Tuple tương tự như list, dùng để chứa dãy các
phần tử. Tuy nhiên:
• List: có thể thay đổi giá trị các phần tử, có thể thêm
mới, có thể xóa bớt phần tử (mutable).

• Tuple: không thể thay đổi giá trị các phần tử, không
thể thêm mới, không thế xóa bớt phần tử
(immutable).

54
 Green

Tạo tuple
• Sử dụng toán tử ( và ) để tạo tuple, thay vì sử dụng
toán tử [ và ] để tạo list.
t = (10, 20, 30, 40, 50)
print(t)

(10, 20, 30, 40, 50)

55
 Green

Truy xuất các phần tử trong tuple

• Tương tự list, sử dụng toán tử [index] để truy xuất
các phần tử trong tuple.
t = (10, 20, 30, 40, 50)

print(t[0]) 10

print(t[4]) 50

print(t[5]) IndexError: tuple index

out of range
print(t[-1]) 50

print(t[1:3]) (20, 30)

print(t[:3]) (10, 20, 30)

print(t[3:]) (40, 50)

print(t[:]) (10, 20, 30, 40, 50)

56
 Green

Lưu ý
• Không thể thay đổi giá trị phần tử, không thể thêm
mới phần tử, không thể xóa phần tử trong tuple.
t = (10, 20, 30, 40, 50)
t[0] = 11
t.append(60)
t.insert(1, 11)
t.pop()

TypeError: 'tuple' object does not support item assignment

AttributeError: 'tuple' object has no attribute 'append'
AttributeError: 'tuple' object has no attribute 'insert'
AttributeError: 'tuple' object has no attribute 'pop'

57
 Green

Sử dụng tuple để làm gì?

• Khi muốn tạo 1 mảng các giá trị, nhưng không cho
phép thay đổi lúc sau.

• Khi muốn truyền 1 mảng làm tham số của 1 hàm,

nhưng không cho phép trong hàm thay đổi giá trị
các phần tử trong tuple.

58
 Green

Chuyển đổi giữa list và tuple

lst = [10, 20, 30, 40, 50]
t = tuple(lst)
lst2 = list(t)
print(lst)
print(t)
print(lst2)

[10, 20, 30, 40, 50]

(10, 20, 30, 40, 50)
[10, 20, 30, 40, 50]

59
 Green

Set
• Set, tập hợp, chứa mảng các phần tử, nhưng các
phần tử không trùng nhau.

• Các phần tử trong set không sắp xếp theo thứ tự

tăng dần hoặc giảm dần.

60
 Green

Tạo set
• Dùng toán tử { và } để tạo set.

• Hoặc dùng hàm set() để chuyển từ list sang set.

s1 ={10, 20, 10, 30, 40, 50}
print(s1)

lst = [10, 20, 30, 40, 50, 20]

s2 = set(lst)
print(s2)

{40, 50, 10, 20, 30}

{40, 10, 50, 20, 30}

61
 Green

Không thể dùng index để truy cập phần tử

s = {10, 20, 10, 40, 50}
print(s[0])

TypeError: 'set' object does not support indexing

62
 Green

Duyệt qua các phần tử trong set

s = {10, 20, 10, 40, 50}
for x in s:
print(x, end=" ")

40 10 50 20

63
 Green

Một số hàm trong set

s = {10, 20, 10, 40, 50}

print(len(s))

s.add(60)
print(s)

s.add(50)
print(s)

4
{40, 10, 50, 20, 60}
{40, 10, 50, 20, 60}

64
 Green

Một số hàm trong set

s = {10, 20, 10, 40, 50}

s.discard(40)
print(s)

s2 = s.copy()
s.add(70)
print(s2)

s.clear()
print(s)

{10, 50, 20}

{10, 50, 20}
set()

65
 Green

s1.difference(s2)
• Hiệu s1 và s2: trả về 1 set mới, chứa các phần tử
chỉ xuất hiện trong s1, không xuất hiện trong s2.
s1 = {1,2,3}
s2 = {1,4,5}
s3 = s1.difference(s2)

print(s1)
print(s2)
print(s3)

{1, 2, 3}
{1, 4, 5}
{2, 3}

66
 Green

s1.intersection(s2)
• Giao s1 và s2: trả về các phần tử xuất hiện cả trong
s1 và s2.
s1 = {1, 2, 3}
s2 ={4, 1, 5}
s3 = s1.intersection(s2)

print(s1)
print(s2)
print(s3)

{1, 2, 3}
{1, 4, 5}
{1}

67
 Green

s1.isdisjoint(s2)
• s1 và s2 không chứa phần tử chung nào đúng
không?
s1 = {1,2}
s2 = {1,2,4}
s3 = {5}

print(s1.isdisjoint(s2))
print(s1.isdisjoint(s3))

False
True

68
 Green

issubset() vs issuperset()
• s1.issubset(s2): s1 có là tập con của s2.

• s1.issuperset(s2): s1 có là tập cha của s2.

s1 = {1,2}
s2 = {1,2,4}

print(s1.issubset(s2))
print(s2.issuperset(s1))

True
True

69
 Green

s1.union(s2)
• Hội s1 và s2: trả về tất cả các phần tử trong tập s1
và tập s2.
s1 = {1,2,3}
s2 = {1,2,4}
s3 = s1.union(s2)

print(s1)
print(s2)
print(s3)

{1, 2, 3}
{1, 2, 4}
{1, 2, 3, 4}

70
 Green

Dictionary
• List: chứa dãy các phần tử, truy xuất mỗi phần tử
thông qua [index]

• Dictionary: chứa dãy các phần tử, truy xuất mỗi

phần tử thông qua [key]
dict = {'key1':'value1','key2':'value2'}

71
 Green

Tạo dictionary
• Sử dụng toán tử { và } và định dạng key: value để
tạo dictionary.

• Sử dụng toán tử [ và ] và key để truy xuất 1 phần tử

trong dictionary.
dict = {'nstnguyen': 'Nguyen Si Trieu Nguyen',
'dtphuyen': 'Doan Thi Phuong Huyen',
'nvaminh': 'Nguyen Viet Anh Minh'}
print(dict['nstnguyen'])
print(dict['htthanh'])
print(dict[0])
print(dict.get('htthanh’))

Nguyen Si Trieu Nguyen

KeyError: 'htthanh'
KeyError: 0
None 72
 Green

Thêm phần tử vào dictionary

attendance = {}
print(attendance)

attendance['nstnguyen'] = 4
print(attendance)

attendance['dtphuyen'] = 4
print(attendance)

attendance['nvaminh'] = 5
print(attendance)

attendance['nstnguyen'] = 5
print(attendance)

{}
{'nstnguyen': 4}
{'dtphuyen': 4, 'nstnguyen': 4}
{'nvaminh': 5, 'dtphuyen': 4, 'nstnguyen': 4}
{'nvaminh': 5, 'dtphuyen': 4, 'nstnguyen': 5}
73
 Green

Xóa phần tử khỏi dictionary

attendance = {'nstnguyen': 4, 'dtphuyen': 4, 'nvaminh': 5}
del attendance['dtphuyen']
print(attendance)

del attendance['htthanh']
print(attendance)

{'nvaminh': 5, 'nstnguyen': 4}
KeyError: 'htthanh'

74
 Green

keys()
• Lấy danh sách các key trong dictionary.
attendance = {'nstnguyen': 4, 'dtphuyen': 4, 'nvaminh': 5}
print(attendance.keys())

dict_keys(['nstnguyen', 'nvaminh', 'dtphuyen'])

75
 Green

values()
• Lấy danh sách value trong dictionary.
attendance = {'nstnguyen': 4, 'dtphuyen': 4, 'nvaminh': 5}
print(attendance.values())

dict_values([5, 4, 4])

76
 Green

items()
• Trả về danh sách cặp (key, value) trong dictionary.
attendance = {'nstnguyen': 4, 'dtphuyen': 4, 'nvaminh': 5}
print(attendance.items())

dict_items([('nvaminh', 5), ('nstnguyen', 4), ('dtphuyen', 4)])

77
 Green

Duyệt các phần tử trong dictionary

attendance = {'nstnguyen': 4, 'dtphuyen': 4, 'nvaminh': 5}
for key in attendance.keys():
print(key + ": " + str(attendance[key]))

nvaminh: 5
nstnguyen: 4
dtphuyen: 4

78
 Green

Toán tử = vs hàm copy()

attendance1 = {'nstnguyen': 4, 'dtphuyen': 4, 'nvaminh': 5}
attendance2 = attendance1
attendance3 = attendance1.copy()
attendance1['dtphuyen'] = 3
print(attendance1)
print(attendance2)
print(attendance3)

{'nvaminh': 5, 'nstnguyen': 4, 'dtphuyen': 3}

{'nvaminh': 5, 'nstnguyen': 4, 'dtphuyen': 3}
{'nvaminh': 5, 'dtphuyen': 4, 'nstnguyen': 4}

79
 Green

Hỏi đáp

80