Tổng quan về Python
Bài viết này giới thiệu các khái niệm cơ bản và cú pháp thiết yếu trong Python, giúp bạn nhanh chóng làm quen với ngôn ngữ lập trình này.
Sự khác biệt giữa Python 2 và Python 3
Một trong những thay đổi quan trọng nhất giữa hai phiên bản này liên quan đến hàm nhập liệu:
- Trong **Python 2**,
raw_input()đọc dữ liệu người dùng dưới dạng chuỗi, vàinput()đọc và thực thi dữ liệu như mã Python. - Trong **Python 3**,
input()đã thay thếraw_input()và luôn đọc dữ liệu dưới dạng chuỗi. Để có hành vi tương tựinput()của Python 2 (thực thi chuỗi nhập vào), bạn cần sử dụngeval(input()).
Khởi tạo và chạy mã Python
Mỗi tập tin Python thường bắt đầu với các dòng sau để chỉ định trình thông dịch và mã hóa ký tự:
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
#!/usr/bin/env python3: Dòng "shebang" này cho hệ điều hành biết rằng script nên được thực thi bằng trình thông dịch Python 3.# -*- coding: utf-8 -*-: Dòng này khai báo mã hóa ký tự của file là UTF-8, hỗ trợ viết mã bằng các ngôn ngữ có ký tự đặc biệt (ví dụ: tiếng Việt).
Để in một thông điệp ra màn hình, bạn sử dụng hàm print():
print("Xin chào Thế giới!")Kết quả đầu ra:
Xin chào Thế giới!Biến trong Python
Biến được sử dụng để lưu trữ dữ liệu. Việc gán giá trị cho biến tuân theo một số quy tắc cụ thể.
Gán giá trị cho biến
Khi gán một giá trị chuỗi, bạn phải đặt nó trong dấu nháy đơn (') hoặc nháy kép ("):
ten_nguoi = 'Nguyễn Bình'
print(ten_nguoi)Nếu bạn bỏ qua dấu nháy cho một chuỗi, Python sẽ coi giá trị đó là một biến chưa được định nghĩa và sẽ báo lỗi:
# Ví dụ gây lỗi:
# ten_nguoi = NguyenBinh
# NameError: name 'NguyenBinh' is not defined
Nếu giá trị là một số, không cần sử dụng dấu nháy:
tuoi = 25
print(tuoi)Bạn cũng có thể gán giá trị của một biến đã định nghĩa cho một biến khác:
so_hien_tai = 10
so_phu = so_hien_tai
print(so_phu)Quy tắc đặt tên biến
- Tên biến có thể chứa chữ cái, số và dấu gạch dưới (
_). - Không được bắt đầu bằng số.
- Không được chứa các ký tự đặc biệt (như
!,@,-, v.v.). - Không được chứa khoảng trắng.
- Python phân biệt chữ hoa chữ thường (
tenvàTenlà hai biến khác nhau).
Ví dụ:
ten_sinh_vien = "Hà"(Hợp lệ)TenSinhVien = "Hà"(Hợp lệ)ten-sinh-vien = "Hà"(Không hợp lệ,-là toán tử trừ)1st_sinh_vien = "Hà"(Không hợp lệ, bắt đầu bằng số)ten sinh vien = "Hà"(Không hợp lệ, chứa khoảng trắng)
Định dạng và hiển thị biến
Để hiển thị giá trị biến trong chuỗi, bạn có thể sử dụng các ký tự định dạng:
%d: Số nguyên (integer)%f: Số thực (floating-point number)%s: Chuỗi (string)%x: Số nguyên ở dạng thập lục phân (hexadecimal integer)
chi_so_pi = 3.14159
ho_ten = "Minh Anh"
so_tuoi = 28
print("Họ tên: %s, Tuổi: %d, Giá trị pi: %.2f" % (ho_ten, so_tuoi, chi_so_pi))
# Kết quả: Họ tên: Minh Anh, Tuổi: 28, Giá trị pi: 3.14
Tham chiếu biến và giá trị
Khi bạn gán một biến cho biến khác, đối với các kiểu dữ liệu bất biến (như số nguyên, chuỗi, tuple), Python sẽ tạo một bản sao của giá trị. Do đó, việc thay đổi biến gốc sau này sẽ không ảnh hưởng đến biến đã được gán:
gia_tri_goc = 100
bien_phu = gia_tri_goc # bien_phu nhận bản sao của giá trị 100
print(f"Giá trị ban đầu của bien_phu: {bien_phu}") # Output: 100
gia_tri_goc = 200 # Thay đổi giá trị của gia_tri_goc
print(f"Giá trị của gia_tri_goc sau thay đổi: {gia_tri_goc}") # Output: 200
print(f"Giá trị của bien_phu vẫn là: {bien_phu}") # Output: 100 (không bị ảnh hưởng)
Điều này cho thấy bien_phu trỏ đến cùng một giá trị 100 trong bộ nhớ tại thời điểm gán, và khi gia_tri_goc được gán lại, nó sẽ trỏ đến một đối tượng mới chứa giá trị 200.
Các hàm dựng sẵn thường dùng trong Python
len(doi_tuong): Trả về số lượng phần tử của một đối tượng (chuỗi, danh sách, tuple, v.v.).dir(doi_tuong): Hiển thị danh sách các thuộc tính và phương thức có sẵn của một đối tượng.id(doi_tuong): Trả về địa chỉ bộ nhớ (ID duy nhất) của đối tượng.type(doi_tuong): Trả về kiểu dữ liệu của đối tượng.
ten_tinh = "Hà Nội"
print(f"Độ dài chuỗi '{ten_tinh}': {len(ten_tinh)}")
print(f"ID của đối tượng '{ten_tinh}': {id(ten_tinh)}")
print(f"Kiểu dữ liệu của đối tượng '{ten_tinh}': {type(ten_tinh)}")
Các kiểu dữ liệu cơ bản
int(Số nguyên): Dùng cho các số nguyên. Ví dụ:10,-50,10000000000. Trong Python 3, kiểuintcó thể lưu trữ số nguyên có độ chính xác tùy ý, không còn kiểulongriêng biệt như Python 2.float(Số thực): Dùng cho các số có phần thập phân. Ví dụ:3.14,-0.001,2.5e-3.complex(Số phức): Dùng cho các số phức. Ví dụ:1 + 2j.bool(Boolean): Dùng để biểu thị giá trị logicTrue(đúng) hoặcFalse(sai).Truecó giá trị tương đương1vàFalsetương đương0trong nhiều ngữ cảnh.
Danh sách (List)
Danh sách là một tập hợp các phần tử có thứ tự, có thể thay đổi (mutable) và cho phép chứa các phần tử có kiểu dữ liệu khác nhau.
# Khai báo một danh sách
danh_sach_hoc_sinh = ["An", "Bình", "Cúc"]
print(f"Danh sách ban đầu: {danh_sach_hoc_sinh}")
# Truy cập phần tử qua chỉ mục (index)
print(f"Học sinh đầu tiên: {danh_sach_hoc_sinh[0]}") # Output: An
# Thêm phần tử vào cuối danh sách
danh_sach_hoc_sinh.append("Dũng")
print(f"Sau khi thêm Dũng: {danh_sach_hoc_sinh}")
# Chèn phần tử vào vị trí cụ thể
danh_sach_hoc_sinh.insert(1, "Hoa") # Chèn Hoa vào vị trí chỉ mục 1
print(f"Sau khi chèn Hoa: {danh_sach_hoc_sinh}")
# Tìm chỉ mục của một phần tử
print(f"Chỉ mục của 'Bình': {danh_sach_hoc_sinh.index('Bình')}")
# Đếm số lần xuất hiện của một phần tử
danh_sach_hoc_sinh.append("An") # Thêm An một lần nữa để minh họa
print(f"Số lần xuất hiện của 'An': {danh_sach_hoc_sinh.count('An')}")
# Xóa phần tử cuối cùng
phan_tu_cuoi_bi_xoa = danh_sach_hoc_sinh.pop()
print(f"Phần tử bị xóa: {phan_tu_cuoi_bi_xoa}, Danh sách còn lại: {danh_sach_hoc_sinh}")
# Xóa phần tử theo giá trị (chỉ xóa lần xuất hiện đầu tiên)
danh_sach_hoc_sinh.remove("An")
print(f"Sau khi xóa 'An' đầu tiên: {danh_sach_hoc_sinh}")
# Đảo ngược thứ tự các phần tử trong danh sách
danh_sach_hoc_sinh.reverse()
print(f"Danh sách đảo ngược: {danh_sach_hoc_sinh}")
# Sắp xếp danh sách (theo thứ tự alphabet cho chuỗi hoặc tăng dần cho số)
danh_sach_hoc_sinh.sort()
print(f"Danh sách đã sắp xếp: {danh_sach_hoc_sinh}")
# Nối hai danh sách
danh_sach_moi = ["Lan", "Minh"]
danh_sach_hoc_sinh.extend(danh_sach_moi)
print(f"Danh sách sau khi nối: {danh_sach_hoc_sinh}")
# Kiểm tra xem một biến có phải là danh sách không
print(f"Biến 'danh_sach_hoc_sinh' có phải là list? {type(danh_sach_hoc_sinh) is list}")
# Xóa tất cả các phần tử có giá trị cụ thể
danh_sach_ten_trung = ['Linh', 'Khanh', 'An', 'Linh', 'Khoa', 'Linh']
print(f"Danh sách có phần tử trùng: {danh_sach_ten_trung}")
while 'Linh' in danh_sach_ten_trung:
danh_sach_ten_trung.remove('Linh')
print(f"Sau khi xóa tất cả 'Linh': {danh_sach_ten_trung}")
# Kiểm tra sự tồn tại của phần tử trong danh sách
ds_so_nguyen = [10, 20, 30, 40]
if 30 in ds_so_nguyen:
print("Số 30 có trong danh sách.")
if 50 not in ds_so_nguyen:
print("Số 50 không có trong danh sách.")
Chuyển đổi giữa Danh sách và Tuple
Bạn có thể dễ dàng chuyển đổi qua lại giữa danh sách (list) và tuple.
Chuyển đổi Tuple thành Danh sách
# Khai báo một tuple
tuple_chu_cai = ('A', 'B', 'C')
print(f"Tuple ban đầu: {tuple_chu_cai}, Kiểu: {type(tuple_chu_cai)}")
# Chuyển đổi thành danh sách
list_chu_cai = list(tuple_chu_cai)
print(f"Danh sách sau chuyển đổi: {list_chu_cai}, Kiểu: {type(list_chu_cai)}")
Chuyển đổi Danh sách thành Tuple
# Khai báo một danh sách
list_thang = ['Tháng 1', 'Tháng 2', 'Tháng 3']
print(f"Danh sách ban đầu: {list_thang}, Kiểu: {type(list_thang)}")
# Chuyển đổi thành tuple
tuple_thang = tuple(list_thang)
print(f"Tuple sau chuyển đổi: {tuple_thang}, Kiểu: {type(tuple_thang)}")
Phương thức xử lý chuỗi cơ bản
Loại bỏ khoảng trắng
Các phương thức strip(), lstrip(), rstrip() giúp loại bỏ khoảng trắng (hoặc các ký tự chỉ định) từ đầu hoặc cuối chuỗi.
chuoi_co_khoang_trang = ' Python là tuyệt vời '
print(f"Chuỗi gốc: '{chuoi_co_khoang_trang}'")
print(f"Sau strip(): '{chuoi_co_khoang_trang.strip()}'") # Loại bỏ khoảng trắng ở hai đầu
print(f"Sau lstrip(): '{chuoi_co_khoang_trang.lstrip()}'") # Loại bỏ khoảng trắng ở đầu trái
print(f"Sau rstrip(): '{chuoi_co_khoang_trang.rstrip()}'") # Loại bỏ khoảng trắng ở đầu phải
Tách chuỗi (Split)
Phương thức split() chia một chuỗi thành một danh sách các chuỗi con dựa trên một ký tự phân tách (delimiter).
thong_tin_san_pham = "Laptop,1200,Dell"
cac_phan_tu = thong_tin_san_pham.split(',')
print(f"Chuỗi sau khi tách: {cac_phan_tu}") # Output: ['Laptop', '1200', 'Dell']
Cắt lát (Slicing)
Cắt lát cho phép bạn trích xuất một phần của danh sách, tuple hoặc chuỗi bằng cách chỉ định một phạm vi chỉ mục.
danh_sach_chu_cai = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
print(f"Từ chỉ mục 2 đến 4: {danh_sach_chu_cai[2:5]}") # Lấy các phần tử từ chỉ mục 2 đến 4 (chỉ mục 5 không bao gồm)
print(f"Từ đầu đến chỉ mục 4: {danh_sach_chu_cai[:5]}") # Lấy các phần tử từ đầu đến chỉ mục 4
print(f"Hai phần tử cuối cùng: {danh_sach_chu_cai[-2:]}") # Lấy hai phần tử cuối cùng
Tuple
Tuple là một tập hợp các phần tử có thứ tự nhưng không thể thay đổi (immutable). Một khi đã tạo, bạn không thể thêm, xóa hoặc sửa đổi các phần tử của tuple.
# Cách tạo tuple
tuple_ngay_sinh = (1, 1, 2000)
print(f"Tuple ngày sinh: {tuple_ngay_sinh}")
# Hoặc sử dụng hàm tuple()
tuple_nguyen_am = tuple(('a', 'e', 'i', 'o', 'u'))
print(f"Tuple nguyên âm: {tuple_nguyen_am}")
# Truy cập phần tử (tương tự danh sách)
print(f"Phần tử đầu tiên của tuple ngày sinh: {tuple_ngay_sinh[0]}") # Output: 1
Từ điển (Dictionary)
Từ điển là một tập hợp các cặp khóa-giá trị (key-value) không có thứ tự và có thể thay đổi. Mỗi khóa trong từ điển phải là duy nhất.
# Cách tạo từ điển
thong_tin_nhan_vien = {
"ho_ten": "Lê Văn An",
"tuoi": 30,
"chuc_vu": "Lập trình viên"
}
print(f"Từ điển nhân viên: {thong_tin_nhan_vien}")
# Hoặc sử dụng hàm dict()
thong_tin_may_tinh = dict({"hang": "HP", "model": "ProBook", "gia": 15000000})
print(f"Từ điển máy tính: {thong_tin_may_tinh}")
# Truy cập giá trị bằng khóa
print(f"Tên nhân viên: {thong_tin_nhan_vien['ho_ten']}") # Output: Lê Văn An
# Duyệt qua từ điển để lấy khóa và giá trị
print("\nThông tin chi tiết:")
for khoa, gia_tri in thong_tin_nhan_vien.items():
print(f" {khoa.replace('_', ' ').capitalize()}: {gia_tri}")
# Lấy tất cả các khóa
print(f"\nCác khóa trong từ điển: {thong_tin_nhan_vien.keys()}")
# Lấy tất cả các giá trị
print(f"Các giá trị trong từ điển: {thong_tin_nhan_vien.values()}")
# Lấy tất cả các cặp khóa-giá trị
print(f"Tất cả các mục trong từ điển: {thong_tin_nhan_vien.items()}")
Vòng lặp (Loops)
Python cung cấp các cấu trúc vòng lặp như for và while để thực hiện các hành động lặp đi lặp lại.
continue và break
continue: Bỏ qua phần còn lại của lần lặp hiện tại và chuyển sang lần lặp tiếp theo của vòng lặp.break: Thoát khỏi vòng lặp chứa nó ngay lập tức.
# Ví dụ về continue (chỉ in số lẻ)
print("Ví dụ với 'continue':")
for num in range(1, 6): # Duyệt từ 1 đến 5
if num % 2 == 0: # Nếu số là chẵn
continue # Bỏ qua lần lặp này
print(num) # Chỉ in số lẻ (1, 3, 5)
# Ví dụ về break (dừng vòng lặp)
print("\nVí dụ với 'break':")
dem_so = 0
while True:
print(f"Giá trị hiện tại: {dem_so}")
dem_so += 1
if dem_so > 3:
break # Thoát vòng lặp khi dem_so vượt quá 3
Các toán tử trong Python
Python hỗ trợ nhiều loại toán tử để thực hiện các phép tính, so sánh và thao tác dữ liệu.
- **Toán tử số học:**
+(cộng),-(trừ),*(nhân),/(chia),%(chia lấy dư),**(lũy thừa),//(chia lấy phần nguyên). - **Toán tử so sánh:**
==(bằng),!=(khác),<(nhỏ hơn),>(lớn hơn),<=(nhỏ hơn hoặc bằng),>=(lớn hơn hoặc bằng). - **Toán tử gán:**
=(gán),+=(cộng và gán),-=(trừ và gán),*=(nhân và gán),/=(chia và gán),%=(chia lấy dư và gán),**=(lũy thừa và gán),//=(chia lấy phần nguyên và gán). - **Toán tử logic:**
and(và),or(hoặc),not(phủ định). - **Toán tử thành viên:**
in(kiểm tra sự tồn tại trong một chuỗi, danh sách, tuple, set hoặc dictionary),not in(kiểm tra sự không tồn tại). - **Toán tử nhận dạng:**
is(kiểm tra xem hai biến có trỏ đến cùng một đối tượng trong bộ nhớ không),is not(kiểm tra không cùng đối tượng). - **Toán tử bitwise:**
&(AND bit),|(OR bit),^(XOR bit),~(NOT bit),<<(dịch trái bit),>>(dịch phải bit).
Thao tác với tệp tin (File Operations)
Để làm việc với tệp tin, bạn sử dụng hàm open(). Python 3 khuyến nghị sử dụng open() thay vì file() (đã bị loại bỏ).
Chế độ mở tệp tin
'r': Chỉ đọc (read). Đây là chế độ mặc định. Con trỏ tệp ở đầu.'w': Chỉ ghi (write). Tạo tệp mới nếu chưa tồn tại. Nếu tệp đã tồn tại, nội dung cũ sẽ bị xóa hoàn toàn. Con trỏ tệp ở đầu.'a': Ghi nối tiếp (append). Tạo tệp mới nếu chưa tồn tại. Nếu tệp đã tồn tại, dữ liệu mới sẽ được thêm vào cuối. Con trỏ tệp ở cuối.'r+': Đọc và ghi. Con trỏ tệp ở đầu.'w+': Ghi và đọc. Xóa nội dung nếu tệp tồn tại hoặc tạo tệp mới. Con trỏ tệp ở đầu.'a+': Ghi nối tiếp và đọc. Dữ liệu mới được thêm vào cuối tệp. Con trỏ tệp ở cuối.'x': Tạo tệp mới và mở để ghi. Nếu tệp đã tồn tại, sẽ báo lỗiFileExistsError.
Bạn có thể kết hợp các chế độ trên với:
'b': Chế độ nhị phân (binary). Ví dụ:'rb','wb'. Cần thiết khi làm việc với các tệp không phải văn bản (ảnh, video).'t': Chế độ văn bản (text). Đây là chế độ mặc định. Ví dụ:'rt'.
# Ghi đè vào tệp tin "thongtin.txt"
with open("thongtin.txt", "w", encoding="utf-8") as file_obj:
file_obj.write("Dòng dữ liệu đầu tiên.\n")
file_obj.write("Đây là dòng thứ hai.\n")
file_obj.write("Và đây là dòng cuối cùng.\n")
print("Đã ghi thành công vào 'thongtin.txt'")
# Đọc toàn bộ nội dung tệp
with open("thongtin.txt", "r", encoding="utf-8") as file_obj:
noi_dung_day_du = file_obj.read()
print("\n--- Nội dung tệp (phương thức .read()) ---")
print(noi_dung_day_du)
# Đọc từng dòng của tệp
with open("thongtin.txt", "r", encoding="utf-8") as file_obj:
print("\n--- Nội dung tệp (phương thức .readline()) ---")
print(file_obj.readline(), end='') # Đọc dòng đầu tiên
print(file_obj.readline(), end='') # Đọc dòng thứ hai
# Đọc tất cả các dòng vào một danh sách
with open("thongtin.txt", "r", encoding="utf-8") as file_obj:
danh_sach_dong = file_obj.readlines()
print("\n--- Nội dung tệp (phương thức .readlines() - dạng danh sách) ---")
print(danh_sach_dong)
Định dạng chuỗi trong Python
Python cung cấp nhiều cách để định dạng chuỗi. Ngoài toán tử % truyền thống, bạn nên ưu tiên sử dụng f-strings (format string literals) hoặc phương thức .format() hiện đại hơn.
ten_nguoi_dung = input("Nhập tên của bạn: ")
tuoi_nguoi_dung = input("Nhập tuổi của bạn: ")
nghe_nghiep_nguoi_dung = input("Nhập nghề nghiệp của bạn: ")
# Cách 1: Sử dụng f-strings (khuyến nghị cho Python 3.6 trở lên)
thong_tin_fstring = f"""
Thông tin cá nhân của {ten_nguoi_dung}:
Tên: {ten_nguoi_dung}
Tuổi: {tuoi_nguoi_dung}
Nghề nghiệp: {nghe_nghiep_nguoi_dung}
"""
print(thong_tin_fstring)
# Cách 2: Sử dụng phương thức .format()
thong_tin_format = """
Thông tin cá nhân của {0}:
Tên: {0}
Tuổi: {1}
Nghề nghiệp: {2}
""".format(ten_nguoi_dung, tuoi_nguoi_dung, nghe_nghiep_nguoi_dung)
print(thong_tin_format)
# Cách 3: Sử dụng toán tử % (cách cũ)
thong_tin_phan_tram = """
Thông tin cá nhân của %s:
Tên: %s
Tuổi: %s
Nghề nghiệp: %s
""" % (ten_nguoi_dung, ten_nguoi_dung, tuoi_nguoi_dung, nghe_nghiep_nguoi_dung)
print(thong_tin_phan_tram)
Điều khiển luồng (Flow Control)
Điều khiển luồng cho phép bạn xác định thứ tự thực hiện các câu lệnh dựa trên các điều kiện.
Trò chơi đoán số với vòng lặp while
# Đoán số không giới hạn số lần
so_bi_mat = 19
so_nguoi_doan = -1
print("--- Trò chơi đoán số (Không giới hạn lượt) ---")
while so_nguoi_doan != so_bi_mat:
try:
so_nguoi_doan = int(input("Hãy đoán một số: "))
if so_nguoi_doan > so_bi_mat:
print("Số bạn đoán quá lớn!")
elif so_nguoi_doan < so_bi_mat:
print("Số bạn đoán quá nhỏ!")
except ValueError:
print("Vui lòng nhập một số nguyên hợp lệ.")
print("Chúc mừng! Bạn đã đoán đúng số.")
# Đoán số với giới hạn 3 lần
so_bi_mat = 25
so_lan_thu = 0
max_lan_thu = 3
print("\n--- Trò chơi đoán số (Giới hạn 3 lượt) ---")
while so_lan_thu < max_lan_thu:
try:
so_nguoi_doan = int(input(f"Lượt đoán {so_lan_thu + 1}/{max_lan_thu}. Đoán số: "))
if so_nguoi_doan > so_bi_mat:
print("Số bạn đoán quá lớn!")
elif so_nguoi_doan < so_bi_mat:
print("Số bạn đoán quá nhỏ!")
else:
print("Tuyệt vời! Bạn đã đoán đúng!")
break # Thoát vòng lặp khi đoán đúng
except ValueError:
print("Vui lòng nhập một số nguyên hợp lệ.")
finally: # Khối này luôn được thực thi
so_lan_thu += 1
else: # Khối else này chỉ chạy nếu vòng lặp kết thúc mà không gặp break
print(f"Bạn đã hết {max_lan_thu} lượt đoán. Số bí mật là: {so_bi_mat}")
Trò chơi đoán số với vòng lặp for
so_bi_mat = 33
max_lan_thu = 4
print("\n--- Trò chơi đoán số (dùng for loop) ---")
for lan in range(max_lan_thu):
try:
so_nguoi_doan = int(input(f"Lượt đoán {lan + 1}/{max_lan_thu}. Đoán số: "))
if so_nguoi_doan > so_bi_mat:
print("Số bạn đoán quá lớn!")
elif so_nguoi_doan < so_bi_mat:
print("Số bạn đoán quá nhỏ!")
else:
print("Chúc mừng! Bạn đã đoán đúng!")
break # Thoát vòng lặp
except ValueError:
print("Vui lòng nhập một số nguyên hợp lệ.")
else: # Khối else này chạy nếu vòng lặp for hoàn thành mà không gặp break
print(f"Bạn đã hết {max_lan_thu} lượt đoán. Số bí mật là: {so_bi_mat}")
Vòng lặp lồng nhau
Vòng lặp lồng nhau là khi một vòng lặp được đặt bên trong một vòng lặp khác. Điều này hữu ích khi bạn cần xử lý dữ liệu có cấu trúc nhiều chiều.
# Ví dụ 1: Vòng lặp while lồng nhau
print("--- Ví dụ vòng lặp while lồng nhau ---")
i_ngoai = 0
while i_ngoai < 3:
print(f"Vòng ngoài i = {i_ngoai}")
j_trong = 0
while j_trong < 2:
print(f" Vòng trong j = {j_trong}")
j_trong += 1
i_ngoai += 1
# Ví dụ 2: Vòng lặp for lồng nhau với continue/break
print("\n--- Ví dụ vòng lặp for lồng nhau (continue/break) ---")
for cot in range(1, 5): # Vòng lặp ngoài
print(f"Processing hàng: {cot}")
for hang in range(1, 6): # Vòng lặp trong
if hang == 1:
continue # Bỏ qua giá trị hang = 1
if hang == 4:
break # Thoát vòng lặp trong khi hang = 4
print(f" Giá trị: {hang}")