-
Bổ Sung Danh Sách ========
-
Sắp xếp Tăng Dần Sử Dụng .sort()
Sắp xếp các phần tử trong danh sách theo thứ tự tăng dần
ds = [33, 22, 11, 22, 11, 33, 22, 77, 66, 55, 44]
ds.sort()
print(ds)
[11, 11, 22, 22, 22, 33, 33, 44, 55, 66, 77]
- Sắp xếp Giảm Dần Sử Dụng .sort(reverse=True)
Sắp xếp các phần tử trong danh sách theo thứ tự giảm dần
ds = [33, 22, 11, 22, 11, 33, 22, 77, 66, 55, 44]
ds.sort(reverse=True)
print(ds)
[77, 66, 55, 44, 33, 33, 22, 22, 22, 11, 11]
# .reverse() có thể sử dụng riêng lẻ để đảo ngược thứ tự của danh sách
- Chỉ Số Trong Danh Sách
Chỉ số cũng có thể được sử dụng để đảo ngược thứ tự các phần tử trong danh sách
ds = [33, 22, 11, 22, 11, 33, 22, 77, 66, 55, 44]
print(ds[:]) # Lấy tất cả các phần tử
print(ds[::-1]) # Lấy các phần tử theo thứ tự ngược lại
print(ds[:5]) # Lấy từ đầu đến chỉ số 5
print(ds[1:]) # Lấy từ chỉ số 1 đến cuối danh sách
- So Sánh Danh SáchSo sánh dựa trên chỉ số tương ứng, kết quả phụ thuộc vào so sánh ở chỉ số đầu tiên
So sánh hai danh sách
danh_sach_1 = [888, 999]
danh_sach_2 = [111, 222, 444]
print(danh_sach_1 > danh_sach_2)
True
# Chuỗi cũng có thể so sánh dựa trên giá trị ASCII của các ký tự
Các Hoạt Động Cơ Bản Với Từ Điển
- Định Nghĩa Từ Điển
# Sử dụng dấu ngoặc nhọn để chứa nhiều cặp khóa-giá trị, phân cách bởi dấu phẩy
# Khóa là thông tin mô tả giá trị, thường là chuỗi
# Khóa phải là kiểu dữ liệu bất biến
# Khóa không thể trùng lặp, nếu trùng sẽ chỉ giữ lại giá trị của khóa cuối cùng
# Giá trị là dữ liệu thực sự, có thể là bất kỳ kiểu dữ liệu nào
- Chuyển Đổi Kiểu Từ Điển Sử Dụng .fromkeys
1. Chuyển đổi trực tiếp nội dung trong ()
print(dict(ten='Alice', tuoi=25, so_thich='đọc sách'))
{'ten': 'Alice', 'tuoi': 25, 'so_thich': 'đọc sách'}
2. Chuyển đổi từ danh sách sang từ điển
thong_tin = dict([['ten', 'Alice'], ('tuoi', 25)])
thong_tin
{'tuoi': 25, 'ten': 'Alice'}
3. fromkeys lấy mỗi giá trị từ tuple làm khóa và ghép với None thành cặp khóa-giá trị
{}.fromkeys(('ten', 'tuoi', 'gioi_tinh'), None)
{'ten': None, 'tuoi': None, 'gioi_tinh': None}
- Lấy Giá Trị Theo Khóa
Lấy giá trị dựa trên khóa, nếu khóa không tồn tại sẽ gây ra lỗi
Lấy giá trị dựa trên khóa
tudien_1 = {'ten': 'Alice', 'tuoi': 25, 'so_thich': 'đọc sách'}
print(tudien_1['ten'])
Alice
- Cập Nhật Giá Trị Theo Khóa, Thêm Cặp Khóa-Giá Trị Mới Nếu Khóa Không Tồn Tại
Cập nhật giá trị hoặc thêm cặp khóa-giá trị mới
tudien_1 = {'ten': 'Alice', 'tuoi': 25, 'so_thich': 'đọc sách'}
tudien_1['ten'] = 'Alicia'
print(tudien_1)
{'ten': 'Alicia', 'tuoi': 25, 'so_thich': 'đọc sách'}
# Nếu khóa tồn tại thì cập nhật giá trị
tudien_1['mau_yeu_thich'] = 'xanh'
print(tudien_1)
{'ten': 'Alicia', 'tuoi': 25, 'so_thich': 'đọc sách', 'mau_yeu_thich': 'xanh'}
- Xóa Phần Tử
1. Sử dụng del
tudien_1 = {'ten': 'Alice', 'tuoi': 25, 'so_thich': 'đọc sách'}
del tudien_1['ten']
print(tudien_1)
{'tuoi': 25, 'so_thich': 'đọc sách'}
2. Sử dụng .pop() # Cần chỉ định khóa, trả về giá trị và xóa khỏi từ điển
tudien_1 = {'ten': 'Alice', 'tuoi': 25, 'so_thich': 'đọc sách'}
gia_tri_da_xoa = tudien_1.pop('ten')
print(gia_tri_da_xoa)
Alice
print(tudien_1)
{'tuoi': 25, 'so_thich': 'đọc sách'}
- Lấy Giá Trị Sử Dụng .get(), Không Báo Lỗi Nếu Khóa Không Tồn Tại
Khi lấy giá trị từ từ điển nên sử dụng .get()
Lấy giá trị sử dụng .get()
tudien_1 = {'ten': 'Alice', 'tuoi': 25, 'so_thich': 'đọc sách'}
print(tudien_1.get('khong_ton_tai'))
None
# Trả về None nếu khóa không tồn tại
print(tudien_1.get('khong_ton_tai', 'Không tìm thấy'))
Không tìm thấy
# Có thể tùy chỉnh kết quả trả về khi khóa không tồn tại
- Lấy Các Khóa, Giá Trị, Hoặc Cặp Khóa-Giá Trị Từ Từ Điểnkeys() .values() .items()
1. Lấy tất cả các khóa
tudien_1 = {'ten': 'Alice', 'tuoi': 25, 'so_thich': 'đọc sách'}
ds_khoa = tudien_1.keys()
print(ds_khoa)
dict_keys(['ten', 'tuoi', 'so_thich'])
2. Lấy tất cả các giá trị
ds_gia_tri = tudien_1.values()
print(ds_gia_tri)
dict_values(['Alice', 25, 'đọc sách'])
3. Lấy tất cả các cặp khóa-giá trị
ds_cap = tudien_1.items()
print(ds_cap)
dict_items([('ten', 'Alice'), ('tuoi', 25), ('so_thich', 'đọc sách')])
- Đếm Số Lượng Cặp Khóa-Giá Trị Trong Từ Điển Sử Dụng len
- Kiểm Tra Thành Viên Sử Dụng in not in, Kết Quả Là True Hoặc False
- Các Phương Thức Trong Tuple ======
Tuple gồm nhiều phần tử phân cách bởi dấu phẩy
Phần tử có thể là bất kỳ kiểu dữ liệu nào, nhưng không thể thay đổi giá trị của phần tử đã tồn tại (không thể thay đổi địa chỉ bộ nhớ mà chỉ số trỏ tới) # Có thể chứa danh sách, có thể thêm phần tử vào danh sách bên trong
Được coi là một phiên bản không thể thay đổi của danh sách
# Chỉ chấp nhận kiểu dữ liệu bất biến
# Thứ tự các phần tử trong tập hợp không đảm bảo
- Chuyển Đổi Kiểu
Có thể chuyển đổi từ bất kỳ kiểu dữ liệu nào có thể lặp thành tuple
# Không thể chuyển đổi số nguyên, chuỗi
1. Chuỗi
print(tuple('chao'))
('c', 'h', 'a', 'o')
2. Danh sách
print(tuple([22, 33.4, 55]))
(22, 33.4, 55)
3. Từ điển
print(tuple({'ten': 'Jason', 'mk': 123}))
('ten', 'mk')
4. Tập hợp
print(tuple({22, 33.4, 55}))
(33.4, 22, 55)
- Định Nghĩa Tuple Một Phần Tử
t1 = (111,)
t2 = (11.11,)
t3 = ('chao',)
# Cần thêm dấu phẩy ngay sau phần tử khi định nghĩa tuple chỉ có một phần tử.
- Kiểu Dữ Liệu Chứa Nhiều Phần Tử
# Kiểu dữ liệu chứa nhiều phần tử khác nhau được gọi là kiểu chứa
# Tất cả các kiểu chứa khi lưu trữ chỉ số đơn lẻ cũng cần thêm dấu phẩy
- Các Phương Thức Trong Tuple
1. Chỉ số, lấy giá trị từ chỉ số
2. Cắt chuỗi, cắt từ trái, từ phải, toàn bộ
3. Bước nhảy
4. len đếm số lượng phần tử
5. Kiểm tra thành viên
6. Vòng lặp for
for i in tuple:
# Lấy từng phần tử lần lượt
7. .count()
# Đếm số lần xuất hiện của phần tử
- Các Phương Thức Trong Tập Hợp ======
Tập hợp gồm nhiều phần tử phân cách bởi dấu phẩy
Phần tử chỉ có thể là kiểu dữ liệu bất biến và không được trùng lặp
# Để định nghĩa tập hợp rỗng cần sử dụng từ khóa
th1 = set()
th2 = {} # Dấu ngoặc nhọn định nghĩa là từ điển
- Chuyển Đổi Kiểu
Có thể chuyển đổi từ bất kỳ kiểu dữ liệu nào có thể lặp thành tập hợp, các phần tử trong kiểu được chuyển đổi phải là bất biến
th = set([1, 2, 3, 4])
{1, 2, 3, 4}
th1 = set((1, 2, 3, 4))
{1, 2, 3, 4}
th2 = set({'ten': 'Jason'})
{'ten'}
th3 = set('egon')
{'e', 'o', 'g', 'n'}
- Các Phương Thức Sử Dụng
1. Hợp
th1 = {"zero", "kevin", "jason", "hello"}
th2 = {"Jy", "ricky", "jason", "hello"}
print(th1 | th2)
{'zero', 'hello', 'ricky', 'kevin', 'Jy', 'jason'}
# Loại bỏ phần tử trùng lặp và giữ lại một phần tử duy nhất
2. Giao
th1 = {"zero", "kevin", "jason", "hello"}
th2 = {"Jy", "ricky", "jason", "hello"}
print(th1 & th2)
{'hello', 'jason'}
# Lấy các phần tử trùng lặp
3. Hiệu
th1 = {"zero", "kevin", "jason", "hello"}
th2 = {"Jy", "ricky", "jason", "hello"}
print(th1 - th2)
{'zero', 'kevin'}
# Lấy các phần tử trong th1 mà không có trong th2
th1 = {"zero", "kevin", "jason", "hello"}
th2 = {"Jy", "ricky", "jason", "hello"}
print(th2 - th1)
{'Jy', 'ricky'}
# Tương tự
4. So Sánh Bằng Nhau (==)
th1 = {"zero", "kevin", "jason", "hello"}
th2 = {"Jy", "ricky", "jason", "hello"}
print(th2 == th1)
False
# Trả về True hoặc False
5. Tập Con, Tập Cha
th1 = {1, 2, 3}
th2 = {1, 2}
print(th2 < th1)
True
# Trả về True hoặc False, kiểm tra xem th2 có chứa tất cả các phần tử của th1 hay không
- Bài Tập
Dễ: Loại bỏ trùng lặp
Trung bình: Loại bỏ trùng lặp và giữ nguyên thứ tự
Khó: Loại bỏ trùng lặp, giữ nguyên thứ tự, sau đó sắp xếp giảm dần
1. Loại bỏ trùng lặp
l1 = [33, 22, 11, 22, 11, 44, 33, 22, 55, 66, 77, 77, 66, 55, 44]
s1 = set(l1)
l4 = list(s1)
print(l4)
[33, 66, 11, 44, 77, 22, 55]
# 1. Chuyển đổi danh sách thành tập hợp
# 2. Loại bỏ trùng lặp rồi chuyển đổi lại thành danh sách
# 3. Cuối cùng in ra
ll = [33, 22, 11, 22, 11, 44, 33, 22, 55, 66, 77, 77, 66, 55, 44]
# 1. Tạo một danh sách rỗng
l1 = []
# 2. Sử dụng vòng lặp for duyệt qua từng phần tử của ll gán cho i
for i in ll:
# 3. Kiểm tra phần tử i có tồn tại trong danh sách l1 chưa
if i not in l1:
# 4. Nếu không tồn tại thì thêm vào danh sách l1
l1.append(i)
# 5. Cuối cùng in ra danh sách l1
print(l1)
[33, 22, 11, 44, 55, 66, 77]
# Kết thúc
ll = [33, 22, 11, 22, 11, 44, 33, 22, 55, 66, 77, 77, 66, 55, 44]
# 1. Tạo một danh sách rỗng
l1 = []
# 2. Sử dụng vòng lặp for duyệt qua từng phần tử của ll gán cho i
for i in ll:
# 3. Kiểm tra phần tử i có tồn tại trong danh sách l1 chưa
if i not in l1:
# 4. Nếu không tồn tại thì thêm vào danh sách l1
l1.append(i)
# 5. Sắp xếp danh sách l1 theo thứ tự giảm dần
l1.sort(reverse=True)
print(l1)
[77, 66, 55, 44, 33, 22, 11]
# Kết thúc