Biến số

Trong Python, bạn không cần khai báo kiểu dữ liệu khi tạo biến. Chỉ cần đặt tên biến và gán giá trị là có thể sử dụng.

thong_diep = "Chao mung den voi Python!"
a, b, c = 5, 10, 15

Khi khai báo biến, cần tuân thủ các quy tắc sau:

1. Tên biến chỉ được chứa chữ cái, số và dấu gạch dưới. Tên biến có thể bắt đầu bằng chữ cái hoặc dấu gạch dưới, nhưng không được bắt đầu bằng số;
2. Tên biến không được chứa khoảng trắng;
3. Không được dùng từ khóa của Python làm tên biến.

Ngoài ra, tên biến nên:

1. Ngắn gọn và mang tính mô tả;
2. Tránh dùng chữ thường l và chữ hoa O vì dễ nhầm lẫn với số 1 và 0;
3. Nên viết thường toàn bộ và dùng dấu gạch dưới phân cách.

Chuỗi ký tự

Chuỗi là dãy các ký tự. Trong Python, mọi thứ nằm trong dấu ngoặc đều là chuỗi. Dấu ngoặc có thể là đơn hoặc đôi.

chuoi_1 = "Day la mot chuoi."
chuoi_2 = 'Day cung la chuoi.'

Có thể kết hợp cả hai loại dấu ngoặc trong trường hợp đặc biệt:

chuoi_1 = "Toi la sinh vien."
chuoi_2 = 'Toi thich con "meo" nay'

Sử dụng biến trong chuỗi với định dạng f-string và dấu ngoặc nhọn:

ten_dem = "Van"
ho_ten = "Minh"
ten_day_du = f"{ho_ten} {ten_dem}"
ten_chuan_hoa = f"{ten_day_du.title()}"

Một số phương thức chuỗi phổ biến:

Phương thức	Chức năng	Ví dụ	Kết quả
upper()	In hoa	'xin chao'.upper()	XIN CHAO
lower()	In thường	'XIN CHAO'.lower()	xin chao
title()	In hoa chữ cái đầu mỗi từ	'xin chao'.title()	Xin Chao
rstrip()	Xóa khoảng trắng bên phải	' python '.rstrip()	<khoảng trắng>python
lstrip()	Xóa khoảng trắng bên trái	' python '.lstrip()	python<khoảng trắng>
strip()	Xóa khoảng trắng hai bên	' python '.strip()	python

Số nguyên và số thực

Số không có phần thập phân là số nguyên, số có phần thập phân là số thực. Với các số lớn, có thể dùng dấu gạch dưới để phân cách, giúp dễ đọc hơn.

so_lon = 15_000_000_000

Toán tử số học

Phép toán	Dấu hiệu	Ví dụ	Kết quả
Cộng	+	5+3	8
Trừ	-	7-2	5
Nhân	*	6*4	24
Chia	/	8/2	4.0
Lũy thừa	**	3**4	81
Chia lấy dư	%	7 % 2	1

Lưu ý:

1. Kết quả của phép chia luôn là số thực, ngay cả khi hai số nguyên chia hết cho nhau;
2. Trong bất kỳ phép toán nào có một toán hạng là số thực, kết quả luôn là số thực.

>>> 8/2
4.0
>>> 2 + 3.0
5.0

Hàm toán học

Hàm	Ý nghĩa	Ví dụ	Kết quả
min()	Tìm giá trị nhỏ nhất	min([2,4,6,8,10,12])	2
max()	Tìm giá trị lớn nhất	max([2,4,6,8,10,12])	12
sum()	Tính tổng	sum([2,4,6,8,10,12])	42

Ghi chú

Sử dụng # để ghi chú:

# In ra lời chào
print("Xin chao moi nguoi!")

Sử dụng """ để tạo docstring, thường dùng để mô tả chức năng của hàm, được tích hợp vào tài liệu chương trình.

def hien_thi_ten(ten):
    """Hiển thị tên người dùng"""
    print(ten)

Danh sách

Danh sách là tập hợp các phần tử được sắp xếp theo thứ tự xác định. Danh sách được biểu diễn bằng dấu ngoặc vuông [], phân cách bằng dấu phẩy.

xe_dap = ['giant', 'cube', 'trek', 'cannondale', 'specialized']

Truy cập phần tử

Chỉ mục của danh sách bắt đầu từ 0, dùng cú pháp [chỉ_mục] để truy cập phần tử:

print(xe_dap[0]) # giant
print(xe_dap[2]) # trek

Sử dụng chỉ mục âm để truy cập ngược từ cuối danh sách:

print(xe_dap[-1]) # specialized
print(xe_dap[-3]) # trek

Xóa phần tử

Có ba cách xóa phần tử khỏi danh sách:

1. del - xóa phần tử tại chỉ mục cụ thể;
2. pop - xóa phần tử cuối cùng hoặc tại chỉ mục xác định;
3. remove - xóa phần tử có giá trị cụ thể.

del xe_dap[0]
del xe_dap[2]
xe_dap.pop()
xe_dap.pop(1)
xe_dap.remove('giant')

Phương thức remove chỉ xóa lần xuất hiện đầu tiên của phần tử. Nếu có nhiều phần tử giống nhau, cần dùng vòng lặp để xóa tất cả.

Sửa đổi phần tử

Sửa đổi giá trị thông qua chỉ mục:

xe_hoi = ['Toyota', 'Honda', 'Ford', 'BMW']
xe_hoi[0] = 'Mercedes'

Thêm phần tử

Dùng append() để thêm vào cuối, dùng insert() để thêm vào vị trí bất kỳ:

xe_hoi.append('Audi')
xe_hoi.insert(0, 'Nissan')

Sắp xếp danh sách

Dùng sort để sắp xếp vĩnh viễn, dùng sorted để sắp xếp tạm thời:

xe_hoi.sort() # theo thứ tự tăng dần
xe_hoi.sort(reverse=True) # theo thứ tự giảm dần

Dùng reverse để đảo ngược thứ tự danh sách:

xe_hoi.reverse()

Độ dài danh sách

Sử dụng len() để lấy độ dài danh sách:

len(xe_hoi)

Duyệt danh sách

Sử dụng vòng lặp for-in để duyệt danh sách:

for xe in xe_hoi:
    print(xe)

Danh sách số

Sử dụng hàm range() để tạo dãy số, sau đó chuyển thành danh sách bằng list():

for gia_tri in range(1,11):
    print(gia_tri) # 1 2 3 4 5 6 7 8 9 10

for gia_tri in range(1,11,2):
    print(gia_tri) # 1 3 5 7 9 11

danh_sach_so = list(range(1,11)) # [1,2,3,4,5,6,7,8,9,10]

List comprehension là cách viết gọn vòng lặp và tạo phần tử mới thành một dòng:

binh_phuong = [gia_tri**2 for gia_tri in range(1,11)]

Phân đoạn

Phần của danh sách được gọi là phân đoạn (slice). Sử dụng dấu hai chấm (:) để xác định phân đoạn:

nguoi_choi = ['An', 'Binh', 'Cuong', 'Dung', 'Em']
print(nguoi_choi[0:3]) # An Binh Cuong
print(nguoi_choi[:2]) # An Binh
print(nguoi_choi[2:]) # Cuong Dung Em
print(nguoi_choi[-1]) # Em
print(nguoi_choi[-2:]) # Dung Em

Có thể duyệt phân đoạn bằng vòng lặp:

for nguoi in nguoi_choi:
    print(nguoi)

Để sao chép danh sách, dùng cú pháp [:]:

nguoi_choi_moi = nguoi_choi[:] # Tạo bản sao của nguoi_choi

Bộ dữ liệu

Danh sách có thể thay đổi, nếu muốn tạo danh sách không thể thay đổi, dùng tuple. Tuple sử dụng dấu ngoặc tròn (), truy cập phần tử qua chỉ mục.

dien_thoai = ('Samsung', 'Apple', 'Oppo', 'Vivo')
print(dien_thoai[0])

for dt in dien_thoai:
    print(dt)

Từ điển

Từ điển là tập hợp các cặp khóa-giá trị. Mỗi khóa tương ứng với một giá trị. Từ điển dùng dấu ngoặc nhọn {}, khóa và giá trị phân cách bằng dấu hai chấm, các cặp khóa-giá trị phân cách bằng dấu phẩy.

hoc_sinh = {'ho_ten':'Nguyen Van A', 'lop':'10A1'}
diem_so = {'ho_ten':'Nguyen Van A', 'lop':'10A1', 'diem':[85, 90, 78, 92]} # giá trị là danh sách
thong_tin = {'ho_ten':'Nguyen Van A', 'lop':'10A1', 'chi_tiet': {'tuoi':17, 'toan':95}} # giá trị là từ điển

Truy cập, sửa đổi và xóa

Sử dụng [khóa] để truy cập hoặc sửa đổi giá trị:

print(hoc_sinh['ho_ten'])
hoc_sinh['ho_ten'] = 'Le Thi B'

Dùng del để xóa cặp khóa-giá trị:

del hoc_sinh['ho_ten']

Việc truy cập bằng [khóa] có nhược điểm: nếu khóa không tồn tại sẽ gây lỗi. Để tránh lỗi này, dùng phương thức get() với giá trị mặc định:

hoc_sinh.get('gioi_tinh', 'nam')

Thêm cặp khóa-giá trị

Thêm cặp khóa-giá trị như sau:

hoc_sinh['tuoi'] = 18

Có thể tạo từ điển rỗng rồi thêm dần:

sach = {}
sach['ten'] = 'Harry Potter'

Duyệt từ điển

Duyệt tất cả cặp khóa-giá trị dùng items(), duyệt tất cả khóa dùng keys(), duyệt tất cả giá trị dùng values().

nguoi_dung = {
    'tai_khoan': 'nguyen.vana',
    'mat_khau': 'password123',
    'lan_dang_nhap': '2024-03-15 14:30:00'
}

# Duyệt cặp khóa-giá trị
for khoa, gia_tri in nguoi_dung.items():
    print(f'khoa={khoa}, gia_tri={gia_tri}')

# Duyệt tất cả khóa
for khoa in nguoi_dung.keys():
    print(f'khoa={khoa}')

# Duyệt tất cả giá trị
for gia_tri in nguoi_dung.values():
    print(f'gia_tri={gia_tri}')

Cấu trúc lựa chọn

Biểu thức điều kiện

Một câu lệnh trả về True hoặc False được gọi là biểu thức điều kiện, còn gọi là biểu thức luận lý.

So sánh	Ý nghĩa	Ví dụ	Kết quả
==	Bằng nhau	2 == 3	False
!=	Khác nhau	2 != 3	True
>	Lớn hơn	2 > 3	False
<	Nhỏ hơn	2 < 3	True
>=	Lớn hơn hoặc bằng	2 >= 3	False
<=	Nhỏ hơn hoặc bằng	2 <= 3	True
in	Kiểm tra phần tử có trong danh sách	2 in [2,4,6,8,10]	True
not in	Kiểm tra phần tử không có trong danh sách	2 not in [2,4,6,8,10]	False

Khi kết hợp nhiều điều kiện, dùng and hoặc or để nối các biểu thức điều kiện:

So sánh	Ý nghĩa	Ví dụ	Kết quả
and	Và	2 != 3 and 4 != 5	True
or	Hoặc	2 > 3 or 4 < 5	True

if-elif-else

Cấu trúc lựa chọn có ba hình thức:

1. Chỉ có if;
2. if-else;
3. if-elif-else cấu trúc phức hợp, trong đó có thể có nhiều elif. Câu lệnh else có thể bỏ tùy tình huống.

tuoi = 25

# Cấu trúc chỉ có if
if tuoi < 18:
    print('Chua du tuoi thanh nien')

# Cấu trúc if-else
if tuoi < 18:
    print('Chua du tuoi thanh nien')
else:
    print('Da du tuoi thanh nien')

# Cấu trúc if-elif-else phức hợp
if tuoi < 1:
    print('Tre so sinh')
elif tuoi < 18:
    print('Thieu nien')
elif tuoi < 30:
    print('Thanh nien')
elif tuoi < 60:
    print('Trung nien')
else: # Có thể bỏ tùy tình huống
    print('Lao nhan')

if kiểm tra danh sách rỗng

Khi danh sách không có phần tử nào, ta gọi là danh sách rỗng. Câu lệnh if có thể kiểm tra danh sách có rỗng hay không:

nguoi_dung = []
if nguoi_dung:
    print('Danh sach nguoi dung khong rong.')
else:
    print('Danh sach nguoi dung rong.')

Cấu trúc lặp

Có hai loại cấu trúc lặp: vòng lặp for-in và vòng lặp while. Vòng lặp for-in thường dùng với danh sách hoặc từ điển, còn vòng lặp while độc lập hơn. Vòng lặp while tiếp tục chạy đến khi điều kiện không còn đúng.

dem = 0
while dem <= 10: # Tiếp tục thực thi miễn là điều kiện đúng
    print(dem)
    dem += 1

Dùng break để thoát khỏi vòng lặp, dùng continue để bỏ qua lần lặp hiện tại và chuyển sang lần lặp tiếp theo:

dem = 0
while dem <= 10:
    if dem in [2,4,6,8]:
        continue # Khi dem là 2,4,6,8 thì bỏ qua câu lệnh sau và tiếp tục vòng lặp
    if dem == 7:
        break # Khi dem bằng 7 thì kết thúc vòng lặp sớm
    print(dem)
    dem += 1

Khi dùng vòng lặp for-in, không nên sửa đổi danh sách hoặc từ điển đang duyệt, vì điều này khiến Python khó theo dõi các phần tử. Muốn vừa duyệt vừa xử lý phần tử, nên dùng vòng lặp while.

nguoi_moi = ['An', 'Binh', 'Cuong']
nguoi_xac_nhan = []

while nguoi_moi:
    print(nguoi_moi)
    nguoi = nguoi_moi.pop()
    print(f'Da lay nguoi: {nguoi} tu danh sach moi.')
    nguoi_xac_nhan.append(nguoi)

print(f'Nguoi da xac nhan: {nguoi_xac_nhan}')

Nhập liệu người dùng

Dùng phương thức input() để nhận chuỗi nhập từ người dùng.

thong_bao = input('Nhap noi dung bat ky, toi se lap lai cho ban: ')
print(thong_bao)

# Vì input luôn trả về chuỗi, nên cần dùng int() để chuyển chuỗi thành số
tuoi = input('Nhap tuoi cua ban: ')
tuoi = int(tuoi)
if tuoi < 18:
    print('Chua du tuoi')
else:
    print('Da du tuoi')

Hàm

Hàm là khối mã có tên, dùng từ khóa def để định nghĩa hàm, dùng dấu ngoặc để xác định tham số nhận vào.

# Định nghĩa hàm
def chao_mung():
    print("Xin chao!")

# Gọi hàm
chao_mung()

Tham số hình thức và thực tế

Tham số trong định nghĩa hàm gọi là tham số hình thức, tham số truyền khi gọi hàm gọi là tham số thực tế. Khi định nghĩa hàm, có thể thiết lập trước tham số hình thức.

def chao_mung(ten):
    print(f'Xin chao, {ten}!')

chao_mung('Ngoc Anh')

Dựa vào vị trí, tham số thực tế chia thành: tham số vị trí và tham số từ khóa. Tham số vị trí yêu cầu thứ tự trùng khớp giữa tham số thực tế và hình thức:

def chao_mung(ho, ten):
    print(f'Ten cua ban la {ho} {ten}')

chao_mung('Nguyen', 'An')

Tham số từ khóa liên kết tên tham số với giá trị, nên thứ tự có thể khác nhau:

def chao_mung(ho, ten):
    print(f'Ten cua ban la {ho} {ten}')

chao_mung(ho='Nguyen', ten='An')
chao_mung(ten='An', ho='Nguyen')

Giá trị mặc định cho tham số

Khi định nghĩa tham số hình thức, có thể đặt giá trị mặc định, khi gọi hàm có thể truyền hoặc không:

def chao_mung(ho, ten, truong='Truong THCS Le Loi'):
    print(f'Ten ban la {ho} {ten} va hoc tai {truong}')

chao_mung('Tran', 'Binh', 'Truong THPT Nguyen Trai')
chao_mung('Le', 'Cuong')

Giá trị trả về của hàm

Trong hàm, dùng câu lệnh return để trả về giá trị.

def ten_day_du(ho, ten):
    return f'{ho} {ten}'

ten_day_du = ten_day_du('Tran', 'Minh')
print(ten_day_du)

Truyền tham chiếu

Khi tham số hình thức là danh sách, từ điển... thì việc truyền tham số là truyền theo tham chiếu.

def sua_doi(danh_sach_so):
    danh_sach_so.append(5)  # Sửa đổi danh sách trong hàm

so_nguyen = [1, 2, 3, 4]
sua_doi(so_nguyen)
print(so_nguyen)  # In ra [1, 2, 3, 4, 5]

Sử dụng phân đoạn để tránh thay đổi danh sách gốc:

def sua_doi(danh_sach_so):
    danh_sach_so.append(5)  # Sửa đổi danh sách trong hàm

so_nguyen = [1, 2, 3, 4]
sua_doi(so_nguyen[:])  # Truyền bản sao của danh sách
print(so_nguyen)  # In ra [1, 2, 3, 4]

Tham số tùy ý

Khi không biết trước số lượng tham số, dùng tham số tùy ý. Dùng * cho tuple, ** cho từ điển.

def in_so(*cac_so):
    print(cac_so)

in_so(1)
in_so(1, 2)
in_so(1, 2, 3)
in_so(1, 2, 3, 4)
in_so(1, 2, 3, 4, 5)

def in_ten(**cac_ten):
    print(cac_ten)

in_ten(ho='Nguyen', ten='Van')

Nhập module bên ngoài

Có ba cách để nhập hàm từ module khác:

1. Nhập toàn bộ module;
2. Nhập tất cả hàm và biến trong module;
3. Nhập hàm hoặc biến cụ thể trong module.

# Nhập toàn bộ module
import ten_module

# Nhập tất cả hàm và biến trong module
from ten_module import *

# Nhập hàm hoặc biến cụ thể trong module
from ten_module import ten_ham, ten_bien

Khác biệt giữa cách 1 và 2: Cách 1 cần dùng cú pháp tên_module.tên_hàm để gọi hàm. Cách 2 gọi trực tiếp tên hàm. Do đó, cách 1 tránh được xung đột tên hàm, cách 2 thì không (gây ô nhiễm môi trường). Nên ưu tiên cách 1.

Sau khi nhập hàm hoặc module, có thể đặt tên khác bằng từ khóa as:

import ten_module as tm
from ten_module import * as all_items

Lớp

Đối tượng trong thế giới thực có thể trừu tượng hóa thành lớp. Lớp dùng từ khóa class, gồm thuộc tính và phương thức (hàm trong lớp gọi là phương thức). Đặt tên lớp theo chuẩn PascalCase.

class Cho:

    def __init__(self, ten, tuoi):
        self.ten = ten
        self.tuoi = tuoi

    def dat_tuoi(self, tuoi_moi):
        self.tuoi = tuoi_moi
    
    def nguoi(self):
        print(f'{self.ten} dang nguoi')

    def lat_nguoc(self):
        print(f'{self.ten} da lat nguoc!')

__init__() là phương thức khởi tạo, tất cả đối tượng được tạo đều gọi phương thức này. Tham số self là bắt buộc và phải đứng đầu, vì Python tự động truyền tham số này khi tạo đối tượng. self là tham chiếu trỏ đến chính đối tượng, giúp đối tượng truy cập thuộc tính và phương thức trong lớp. ten và tuoi là thuộc tính của lớp, được truy cập qua tham số self. nguoi() và lat_nguoc() là các phương thức.

Sau khi tạo lớp, khởi tạo đối tượng và gọi phương thức:

con_cho_cua_toi = Cho('Miu', 3)
con_cho_cua_toi.nguoi()
con_cho_cua_toi.lat_nguoc()

con_cho_cua_ban = Cho('Bim', 2)
con_cho_cua_ban.nguoi()
con_cho_cua_ban.lat_nguoc()

Giá trị thuộc tính

Có thể đặt giá trị mặc định cho thuộc tính trong phương thức khởi tạo:

class Cho:

    def __init__(self, ten, tuoi):
        self.ten = ten
        self.tuoi = tuoi
        self.mau_long = 'Vang'

    def dat_tuoi(self, tuoi_moi):
        self.tuoi = tuoi_moi
    
    def nguoi(self):
        print(f'{self.ten} dang nguoi')

    def lat_nguoc(self):
        print(f'{self.ten} da lat nguoc!')

con_cho_cua_toi = Cho('Miu', 3)
con_cho_cua_toi.tuoi = 4 # Sửa đổi giá trị thuộc tính
con_cho_cua_toi.dat_tuoi(5) # Sửa đổi qua phương thức

Kế thừa

Khi một lớp kế thừa lớp khác, nó tự động nhận tất cả thuộc tính và phương thức của lớp cha. Lớp gốc gọi là lớp cha, lớp mới gọi là lớp con. Lớp con có thể định nghĩa thuộc tính và phương thức riêng. Khi kế thừa, lớp cha cần được định nghĩa trước. Thông thường, trong phương thức khởi tạo của lớp con cần gọi phương thức khởi tạo của lớp cha.

class Xe:

    def __init__(self, mau, hang):
        self.mau = mau
        self.hang = hang

    def chay(self, ten_lai_xe):
        print(f'{ten_lai_xe} dang dieu khien chiec xe {self.hang}.')

class XeDien(Xe): # kế thừa lớp cha

    def __init__(self, mau, hang):
        super().__init__(mau, hang) # gọi phương thức khởi tạo của lớp cha

    def chay(self, ten_lai_xe): # ghi đè phương thức của lớp cha
        print(f'{ten_lai_xe} dang dieu khien chiec xe {self.mau} {self.hang}. Day la xe dien.')
		

xe = XeDien('Xanh', 'VinFast')
xe.chay('Anh Nam')

Thao tác tệp tin

Dùng hàm open() để mở tệp, close() để đóng tệp, read(), readline(), readlines() để đọc, write() hoặc writelines() để ghi, dùng câu lệnh with-as để tự động đóng tệp.

# Mở tệp ở chế độ chỉ đọc
tep = open('tap_tin.txt', 'r')

# Mở tệp ở chế độ ghi (nếu tệp chưa tồn tại sẽ tạo mới)
tep = open('tap_tin.txt', 'w')

# Mở tệp ở chế độ nối (nếu tệp chưa tồn tại sẽ tạo mới)
tep = open('tap_tin.txt', 'a')

# Đọc toàn bộ nội dung tệp
noi_dung = tep.read()

# Đọc một dòng
dong = tep.readline()

# Đọc tất cả dòng và lưu vào danh sách
danh_sach_dong = tep.readlines()

# Ghi chuỗi vào tệp
tep.write('Xin chao, The gioi!')

# Ghi nhiều dòng chuỗi vào tệp
danh_sach_dong = ['Dong 1\n', 'Dong 2\n', 'Dong 3\n']
tep.writelines(danh_sach_dong)

# Đóng tệp
tep.close()

# Tự động đóng tệp
# Khi khối with kết thúc, tệp sẽ tự động đóng mà không cần gọi tep.close()
with open('tap_tin.txt', 'r') as tep:
    print(tep.read())

Xử lý tệp JSON

Sau khi nhập module json, có thể xử lý tệp ở định dạng json. Dùng json.dump() để lưu dữ liệu json ra tệp, dùng json.load() để đọc tệp json.

import json

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

ten_tep = 'so_nguyen.json'
with open(ten_tep, 'w') as tep_ghi:
    json.dump(cac_so, tep_ghi)

with open(ten_tep, 'r') as tep_doc:
    cac_so_moi = json.load(tep_doc)
    print(cac_so_moi)

Xử lý ngoại lệ

Lỗi xảy ra khi chương trình chạy được gọi là ngoại lệ. Xử lý ngoại lệ dùng câu lệnh try-except-else, trong đó câu lệnh else có thể bỏ qua.

try:
    with open('tap_tin.txt', 'r') as f:
        noi_dung = f.read()
except:
    print("Doc that bai.")
else:
    print("Doc thanh cong.")

Khi ngoại lệ xảy ra, cũng có thể không xử lý gì cả, hành vi này gọi là thất bại im lặng. Dùng từ khóa pass để đánh dấu thất bại im lặng.

try:
    with open('tap_tin.txt', 'r') as f:
        noi_dung = f.read()
except:
    pass # That bai im lang
else:
    print("Doc thanh cong.")

None

None là một kiểu đặc biệt, biểu thị giá trị rỗng hoặc thiếu. None thường dùng để biểu thị biến chưa được gán giá trị. Dùng None giúp xử lý tốt hơn việc gán giá trị biến và kiểm tra trạng thái.

# Có thể gán trực tiếp biến thành None. Biến được gán None sẽ bị xóa nội dung, giải phóng bộ nhớ và đánh dấu là chưa sử dụng.
x = None

# Kiểm tra có phải None không, dùng từ khóa is
if x is None:
    print('X la None.')
else:
    print(x)

# Nếu hàm không trả về giá trị rõ ràng thì mặc định trả về None.
def chao_mung_nguoi_dung():
    return None

Thử nghiệm đơn vị

Thử nghiệm đơn vị dùng để kiểm tra hàm có hoạt động đúng không. Nhập module unittest, lớp thử nghiệm kế thừa từ unittest.TestCase để thực hiện thử nghiệm đơn vị.

import unittest

def cong(a, b):
    return a + b

class KiemTraCong(unittest.TestCase):  # kế thừa lớp thử nghiệm
    def test_cong(self):  # phương thức thử nghiệm
        self.assertEqual(cong(2, 3), 5)

if __name__ == '__main__':
    unittest.main()

Phương thức khẳng định

Kiểm tra kết quả thực tế có trùng với kết quả mong đợi không được gọi là khẳng định.

Phương thức	Ý nghĩa	Ví dụ	Kết quả
assertEqual(a, b)	Kiểm tra có bằng nhau không	assertEqual(2, 3)	False
assertNotEqual(a, b)	Kiểm tra có khác nhau không	assertNotEqual(2, 3)	True
assertTrue(x)	Kiểm tra có phải True không	assertTrue(2 == 3)	False
assertFalse(x)	Kiểm tra có phải False không	assertFalse(2 == 3)	True
assertIn(muc, danh_sach)	Kiểm tra mục có trong danh sách không	assertIn(4, [2, 4, 6, 8])	True
assertNotIn(muc, danh_sach)	Kiểm tra mục không có trong danh sách	assertNotIn(4, [2, 4, 6, 8])	False

setUp và tearDown

unittest hỗ trợ thực hiện các thao tác chuẩn bị và dọn dẹp trước và sau mỗi phương thức thử nghiệm, dùng phương thức setUp và tearDown.

class KiemTraChuoi(unittest.TestCase):

    def setUp(self):
        # Gọi trước mỗi phương thức thử nghiệm
        pass

    def tearDown(self):
        # Gọi sau mỗi phương thức thử nghiệm
        pass