1. Chuyển mã nguồ nC sang Python
1.26. Đếm số từ có trong xâu
s=input("Nhap xau ky tu: ") c = 1
for i in range len( (s)) : if s[i].isspace(): c+=1
print("So tu co trong xau la: "+str(c))
Ta thấy rằng 2 từ sẽ được ngăn cách nhau bởi dấu cách, do đó số từ bằng số dầu cách cộng thêm 1. Vì vậy với biến đếm c khởi tạo bằng 1, ta tiến hành đếm xem trong xâu có bao nhiêu dấu cách để tính ra số từ.
Cần sử dụng hàm c.isspace() để kiểm tra một ký tự có là dấu cách không. 1.27. Chuyển các ký tự đầu mỗi từ thành chữ hoa, còn lại thành chữ thường
s=input(“Nhap xau ky tu: “) new=””
if s[ ].islower():0 new+=s[ ].upper()0 for i in range( ,1 len(s)): if s[i- ].isspace():1 new+=s[i].upper() else:
new+=s[i].lower()
print(“Chuoi moi: “+ new)
Ta lại cần duyệt xâu đầu vào trong s. Với mỗi từ trong s (hoặc là đầu xâu, hoặc là sau dấu cách) ta biến đổi chữ cái đầu thành chữ hoa, các chữ sau thành chữ thường rồi lần lượt thêm vào new, là mảng lưu kết quả.
Sử dụng hàm c.upper() để biến đổi xâu, ký tự thành chữ hoa và hàm lower() để biến thành chữ thường.
1.28. In ra xâu theo chiều ngược lại
s = input("Nhap xau ky tu: ")
print("Xau theo chieu nguoc lai la:", end=" ") for i in range len( (s), , - ):0 1
print(s[i-1], end="")
Ta chỉ cần xét ngược từ cuối lên trên xâu s nhập vào và in ra từng phần tử. Sử dụng hàm len(s) để lấy độ dài của xâu s.
1.29. Loại bỏ các dấu cách thừa ở trong xâu
s1 = input("Nhap xau ky tu:") s2 = ""
i = 0
# Tim den ky tu dau tien khong phai dau cach
while s1[i].isspace():
i += 1
# Xet tung ky tu cua xau
while i < len(s1):
if not s1[i].isspace():
s2 += s1[i] elif i < len(s1)- :2
if not s1[i+ ].isspace():1 s2 += s1[i]
i += 1
print("Xau moi:"+s2)
Ta lưu xâu đầu vào ở s1, còn xâu s2 là kết quả trả về. Ta bắt đầu duyệt xâu s1 từ vị trí mà ở không phải dấu cách cho đến cuối xâu. Mỗi phần tử được xét đều được thêm vào xâu s2. Nếu phần tử đó là dấu cách và sau nó không phải là dấu cách thì ta vẫn sẽ thêm vào, trừ trường hợp đây là phần tử cuối xâu hoặc sau nó là dấu cách thì ta mới không thêm vào.
1.30. Bài tập về cấu trúc
class SINHVIEN:
def __init__(self, hoten, lop, diemTDC): self.hoten = hoten
self.lop = lop
self.diemTDC = diemTDC
# Vi du bai tap cau truc
sv = []
# Nhap vao so luong va thong tin n sinh vien
n = int input( ("Nhap so luong sinh vien (5 <= n <= 20): ")) while (n < ) | (n > 5 20):
print("So luong sinh vien khong hop le.")
n = int input( ("Nhap so luong sinh vien (5 <= n <= 20): ")) for i in range(n):
print("Nhap thong tin sinh vien thu "+str(i+ ))1 hoten = input("Ho ten: ")
lop = input("Lop: ")
diem = int input( ("Diem thi Tin dai cuong: ")) temp = SINHVIEN(hoten, lop, diem)
sv.append(temp)
print("Danh sach sinh vien vua nhap:")
print("{:^3} {:^30} {:^5} {:^4}".format("STT", "Ho ten", "Lop",
"Diem"))
for i in range(n):
print("{:>3} {:<30} {:<5} {:<4}".format(str(i+1), sv[i].hoten, sv[i].lop, sv[i].diemTDC))
x = float input( ("Nhap so thuc x = "))
print("Danh sach sinh vien co diem nho hon "+str(x))
print("{:^3} {:^30} {:^5} {:^4}".format("STT", "Ho ten", "Lop",
"Diem"))
for i in range(n):
if sv[i].diemTDC < x:
sv[i].hoten, sv[i].lop, sv[i].diemTDC))
# Sap xep theo diem thi tin dai cuong giam dan
for i in range(n- ):1
for j in range(i+1, n):
if sv[i].diemTDC < sv[j].diemTDC: tmp = sv[i]
sv[i] = sv[j] sv[j] = tmp
print("\nDanh sach sinh vien sau khi sap xep: ")
print("{:^3} {:^30} {:^5} {:^4}".format("STT", "Ho ten", "Lop",
"Diem"))
for i in range(n):
print("{:>3} {:<30} {:<5} {:<4}".format(str(i+1), sv[i].hoten, sv[i].lop, sv[i].diemTDC))
Bài toán yêu cầu ta cần nhập một danh sách sinh viên với các thông tin tính Họ tên, Lớp và Điểm Tin đại cương. Sau đó in ra danh sách vừa nhập, danh sách các sinh viên có điểm số nhỏ hơn số x nhập vào và cuối cùng là danh sách các sinh viên theo thứ tự điểm thi giảm dần.
Python là một ngôn ngữ lập trình hướng đối tượng. Đa số mọi thứ trong Python là đối tượng với các thuộc tính, phương thức của nó. Trong ví dụ này, chúng ta sẽ đi xây dựng lớp SINHVIEN với các thuộc tính hoten, lop, diemTDC.
Lệnh class SINHVIEN: để khai báo một lớp. Ta sẽ xây dựng phương thức khởi tạo theo cú pháp chuẩn def __init__(self, hoten, lop, diemTDC): với hoten, lop, diemTDC là các tham số truyền vào. Từ khóa self để tự tham chiếu đến đối tượng (có thể hiểu tương tự this trong Java). Như vậy, lệnh self.hoten = hoten cũng tương tự như trong Java, gán tham số hoten truyền vào cho thuộc tính hoten của đối tượng. Và như cách sử dụng biến trong Python, chúng ta không cần khai báo các thuộc tính này thuộc kiểu dữ liệu gì.
Để tạo đối tượng, ta cần sử dụng phương thức khởi tạo với đầy đủ các tham số truyền vào temp = SINHVIEN(hoten, lop, diem); như vậy, ta đã có một đối tượng
temp thuộc lớp SINHVIEN với các thuộc tính như trên. Đối tượng này sau đó được thêm vào mảng để sử dụng.sv
Để in ra danh sách có dạng như bảng, ta cần in ra các thông tin với một độ rộng cố định. Với hàm format(), ta sử dụng các định dạng: {:^3} để in với độ rộng là 3 và xâu in ra sẽ được căn vào giữa khoảng này; {:>3} để in ra với độ rộng 3 và căn trái; {:<30} để in ra với động rộng 30 và căn lề phải. Ta cần in trước tên cột trong bảng, sau đó với mỗi sinh viên, ta in số thự tự (theo chỉ số của đối tượng trong mảng) và các thông tin cần thiết.
Ở yêu cầu tiếp theo, ta cần nhập vào số x. Ở bước in ra, ta sẽ làm tương tự trên nhưng cần thêm câu lệnh kiểm tra điều kiện, chỉ in ra nếu điểm Tin Đại cương nhỏ hơn số x nhập vào.
Ở yêu cầu cuối cùng, ta sử dụng thuật toán sắp xếp nổi bọt để sắp xếp các đối tượng theo thứ tự điểm thi giảm dần. Cuối cùng in ra như các phần trên.
1.31. Viết hàm tính diện tích và chu vi hình trònPI = 3.14 PI = 3.14 def chuvi(r): return 2*r*PI def dientich(r): return r*r*PI
r = float input( ("Nhap ban kinh r = "))
print("Chu vi hinh tron: {chuvi:.2f}".format(chuvi=chuvi(r)))
print("Dien tich hinh tron:
{dientich:.2f}".format(dientich=dientich(r)))
Trong ví dụ này, ta sẽ nhập vào bán kính của hình tròn, sau đó sử dụng các hàm tính chu vi, diện tích hình tròn mà nhận bán kính là tham số truyền vào để in ra kết quả.
Trong Python, ta sử dụng từ khóa def để khai báo hàm với cú pháp :
def <tên hàm> ( [danh sách tham số truyền vào] ): <lệnh thân hàm>
Và cũng tương tự như biến, ta không cần biết kiểu trả về của hàm cũng như kiểu của tham số truyền vào. Lệnh return là không bắt buộc (tương tự với hàm void như trong C hay Java). Trong ví dụ này, ta cần trả về kết quả là chu vi hay diện tích của hình trong ứng với bán kính là tham số truyền vào. Các lệnh trong thân hàm cũng không được đóng gói trong cặp ngoặc {} mà đánh dầu bằng việc thụt đầu dòng.
1.32. Hàm kiểm tra số nguyên tố
from math import sqrt
# Ham tra ve 1 neu la so nguyen to, tra ve 0 neu khong phai
def kiemtra(a):
flag = 1
limit = int(sqrt(a)+ )1 for i in range(2, limit): if a % i == :0
flag = 0 break
return flag
p = int input( ("Nhap so nguyen p = ")) if kiemtra(p):
print("{} la so nguyen to".format(p)) else:
print("{} khong phai la so nguyen to".format(p))
Đề bài xây dựng hàm để kiểm tra số nhập vào liệu có phải số nguyên tố không. Trong thân hàm, ta khởi tạo biến flag = 1, mặc định số nhập vào số nguyên tố.a
Ta bắt đầu kiểm tra từ 2 đến căn bậc hai của xem có số nào là ước của nó không,a
nếu có ta chuyển cờ flag=0, tức là hợp số và a break khỏi vòng lặp. Kết quả trả về của hàm chính là biến flag.
Lúc này với số nhập vào, p kiemtra(p) trả về 1 nếu p là số nguyên tố, ngược lại trả về 0.
1.33. Viết các hàm nhập, in, tìm giá trị lớn nhất và sắp xếp mảng
def nhap_mang(a, n):
for i in range(n):
a.append(int input( ("a[{}] = ".format(i))))
def xuat_mang(a, n):
for i in range(n):
print str( (a[i]), end=" ") print("")
def so_lon_nhat(a, n):
max = a[ ]0
for i in range(1, n): if max < a[i]: max = a[i]
return max
def sap_xep(a, n):
for i in range(n- ):1
for j in range(i+1, n): if a[i] < a[j]: tmp = a[i] a[i] = a[j] a[j] = tmp
a = []
n = int input( ("Nhap so phan tu n = ")) nhap_mang(a, n)
print("Mang vua nhap:") xuat_mang(a, n)
print("So lon nhat trong mang: "+str(so_lon_nhat(a, n))) sap_xep(a, n)
print("Mang sau khi sap xep:") xuat_mang(a, n)
Đề bài yêu cầu xây dựng các hàm thực hiện các thao tác nhập, in, tìm giá trị lớn nhất và sắp xếp mảng.
Vì trong Python, ta truyền tham số cho hàm là truyền tham chiếu, chỉ khi ta thay đổi tham chiếu này thì liên kết giữa tham số truyền vào với tham số nhận được bị ngắt. Do đó với mảng a là tham số của hàm nhập vào, ta thực hiện thêm phần tử vào mảng thì khi ra khỏi hàm, thay đổi này vẫn lưu lại (khi ta gán thì nó xem như khởi tạo biến khác).
Hàm nhap_mang(a, n) nhận 2 tham số vào là và với biến để lưu mảnga n a
nhập vào và là số phần tử. Ta sử dụng vòng lặp n for để nhập vào số, mỗi số nhậpn
vào thêm vào cuối mảng a bằng phương thức append().
Hàm xuat_mang(a, n) với 2 tham số a và n sẽ in ra n phần tử của mảng a. Trong lệnh print(), ta thêm tham số end=" " để thay vì xuống dòng, các phần tử mảng ngăn cách nhau bởi khoảng trắng.
Hàm so_lon_nhat(a, n) sẽ duyệt toàn bộ mảng a để tìm số lớn nhất, lưu trong biến max và kết quả trả về của hàm là biến này.
Hamg sap_xep(a, n) tiến hành sắp xếp mảng theo thứ tự giảm dần bằng thuật toán sắp xếp nổi bọt (có độ phức tạp O(n ) ). 2
1.34. Hàm so sánh 2 xâu
def kiemtra(s1, s2):
n1 = len(s1) n2 = len(s2)
# Neu 2 xau khac nhua thi do dai khac nhau if n1 != n2: return 0 flag = 1 i=0 while i < n1: if (s1.upper() != s2.upper()): flag = 0 break i +=1 return flag
s1=input("Nhap xau 1: ") s2=input("Nhap xau 2: ") if (kiemtra(s1,s2)):
print("Hai xau giong nhau") else:
print("Hai xau khac nhau")
Đề yêu cầu viết hàm kiemtra(s1, s2) để kiểm tra 2 xâu s1, s2 có giống nhau không. Ta sử dụng hàm len(s) để lấy độ dài xâu. Nếu 2 xâu s1 s2 có độ dài khác nhau, có thể kết luận ngay 2 xâu này khác nhau. Ngược lại, ta cần kiểm tra thêm bằng cách duyệt toàn bộ và so sánh các phần từ của s1 với phần tử ở vị trí tương ứng của s2. Ngay khi tìm ra cặp ký tự nào khác nhau, ta có thể thoát khỏi vòng lặp và trả về kết quả flag=0, tức 2 xâu khác nhau. Nếu duyệt xong tất cả các cặp mà không thấy sai khác, biến flag không thay đổi và giữ nguyên giá trị 1 lúc khởi tạo. Kết luận rằng 2 xâu này giống nhau.
1.35. Viết hàm tính khoảng cách và trung điểm của hai điểm trong không gian 3 chiều. chiều.
from math import sqrt
class POINT3D:
def __init__(self, x, y, z): self.x =x
self.y =y self.z =z
def khoang_cach(p1, p2):
return sqrt((p1.x - p2.x) * (p1.x - p2.x) + (p1.y - p2.y) *
(p1.y - p2.y) + (p1.z - p2.z) * (p1.z - p2.z)) def trung_diem(p1, p2): a = (p1.x + p2.x) / 2 b = (p1.y + p2.y) / 2 c = (p1.z + p2.z) / 2 return POINT3D(a, b, c)
print("Nhap toa do diem 1: ")
p1 = POINT3D(float input( ()), float input( ()), float input( ()))
print("Nhap toa do diem 2: ")
p2 = POINT3D(float input( ()), float input( ()), float input( ()))
print("Khoang cach giua 2 diem: {:<.2f}".format(khoang_cach(p1, p2)))
p = trung_diem(p1, p2)
print("Trung diem cua doan thang: {:<.2f} {:<.2f} {:<.2f}".format(p.x, p.y, p.z))
Để thuận tiên, ta xây dựng lớp POINT3D với các thuộc tính x, y, z là tọa độ của điểm. Hàm khởi tạo nhận tham số chính là 3 tọa độ này.
Hàm def khoang_cach(p1, p2) để tính khoảng cách giữa hai điểm p1, p2. Với p1.x là hoành độ x của p1, khi đó khoảng cách bằng:
√(p1.x−p2.x)2
+(p1.y−p2.y)2
+(p1.z−p2.z)2
Hàm trung_diem(p1, p2) trả về điểm với các tọa độ là trung bình cộng các tọa độ của 2 điểm p1 và p2: ( p1.x2+p2.x;p1.y+p2.y 2 ;p1. z+p2.z 2 ) 1.36. Viết hàm tính x .n def x_mu_n(x, n): if n == :0 return 1 else: return x * x_mu_n(x, n - )1
x = float input( ("Nhap x = ")) n = int input( ("Nhap n = "))
Hàm x_mu_n(x, n) trả về giá trị của x . Ta tiến hành cài đặt hàm theo phươngn pháp đệ quy. Với điều kiện neo là n=0, hàm sẽ trả về giá trị 1. Nếu không ta tiến hành đệ quy theo công thức x = x * x , hay x_mu_n(x, n) = x* x_mu_n(x, n-1).n n-1
1.37. Viết hàm tìm UCLN
def uscln(a, b):
if a == b: return a elif a > b: return uscln(a - b, b) else: return uscln(a, b - a)
a = int input( ("Nhap a = ")) b = int input( ("Nhap b = "))
print("USCLN({}, {}) = {}".format(a, b, uscln(a, b)))
Hàm uscln(a, b) trả về Ước số chung lớn nhất của a và b và được cài đặt theo phương pháp đệ quy. Với trường hợp a=b, kết quả trả về là a, đây chính là điều kiện neo. Với a > b, hàm gọi đệ quy tới uscln(a-b, b) bởi vì (a-b) và a đều đồng dư theo modun b nên ước chung UCLN(a-b, b) = UCLN(a, b). Với trường hợp b>a, ta thực hiện tương tự.
1.38. Nhập mảng, lưu vào file, đọc từ file rồi sắp xếp lại.
# Nhap mang phan tu tu ban phim
n = int input( ("Nhap so phan tu n = ")) a = []
for i in range(n):
a.append(int input( ("a[{}] = ".format(i))))
# Luu vao file
f = open("float.dat", "w") f.write(str(n)+"\n") for i in range(n):
f.write(str(a[i])+"\n") f.close()
# Doc noi dung tu file
f = open("float.dat", "r") n = int(f.readline()) for i in range(n):
a[i] = int (f.readline()) f.close()
# Sap xep mang
for i in range(n- ):1
for j in range(i+1, n): if a[i] > a[j]: tmp = a[i] a[i] = a[j] a[j] = tmp
# Luu vao file
f = open("float_sx.dat", "w") f.write(str(n)+"\n")
for i in range(n):
f.write(str(a[i])+"\n") f.close()
Ta cần nhập vào một mảng, lưu mảng đó vào file. Sau đó lại đọc dữ liệu từ file vào mảng, sắp xếp lại nó và lưu vào một file khác.
Để đọc file, ta cần khai báo con trỏ file f = open(<tên file>, <chế độ mở>) với chế độ mở “w” để ghi và “r” để đọc.
Ở chế độ ghi, hàm f.write(<nội dung ghi>) để ghi nội dung vào file. Mỗi dòng trong file ta sẽ ghi một giá trị.
Ở chế độ đọc, hàm f.readline() để đọc nội dung của dòng trong file. Sau lệnh, con trỏ file trỏ đến dòng kế tiếp.
Sau khi đọc dữ liệu từ file vào mảng, ta sắp xếp mảng theo thứ tự tăng dần, sau đó lại ghi vào một file khác tương tự như trên.
1.39. So sánh nội dung 2 file
path1 = input("Nhap duong dan file 1: ") path2 = input("Nhap duong dan file 2: ") f1 = open(path1, "rb")
f2 = open(path2, "rb")
# Lay kich thuoc file
f1.seek(0, 2) size1 = f1.tell() f2.seek(0, 2) size2 = f2.tell() if size1 != size2:
# 2 file co kich co khac nhau thi khac nhau print("Hai file co noi dung khac nhau.") f1.close()
f2.close() else:
# di chuyen con tro file ve dau f1.seek(0, 0)
f2.seek( , )0 0 flag = 1
while (f1.tell()<size1) & (f2.tell()<size2): buf1 = f1.readline() buf2 = f2.readline() if buf1 != buf2: flag = 0 break f1.close() f2.close() if flag == :1
print("Hai file co noi dung giong nhau.") else:
Nội dung các file
Ở ví dụ này, ta cần so sánh xem nội dung 2 file liệu có giống nhau hay không. Do đó cần file mở file để đọc dữ liệu trong đó.
Đầu tiên ta cần so sánh kích thước file, nếu kích thước 2 file khác nhau thì đương nhiên nội dung phải khác. Hàm sử dụng f.seek(0, 2) (tham số thứ nhất là offset, tức khoảng cách so với một mốc nào đó, tham số thứ hai sẽ chọn mốc, ở đây ta sẽ dịch con trỏ đến đúng vị trí mốc mà số 2 nghĩa là mốc ở cuối file) để dịch chuyển con trỏ file về cuối file, khi này hàm f.tell() trả về vị trí của con trỏ file cũng sẽ là kích thước của file đó.
Nếu kích thước bằng nhau, ta tiến hành kiểm tra nội dung. Lệnh f.seek(0, 0) dịch con trỏ về đầu file (tham số thứ hai bằng 0 tức chọn mốc là đầu file). Dùng hàm
f.readline() để đọc từng dòng của 2 file vào 2 biến tạm buf1 và buf2. Nếu 2 giá trị này khác nhau, ta thoát khỏi vòng lặp này và kết luận 2 file khác nhau.
Nếu đi đến cuối file, tất cả các cặp buf1 và buf2 bằng nhau thì trường cờ flag = 1 không thay đổi, ta sẽ kết luận được là nội dung 2 file này giống nhau.
1.40. Sao chép nội dung file
path1 = input("Nhap duong dan file 1: ") path2 = input("Nhap duong dan file 2: ") f1 = open(path1, "rb")
f2 = open(path2, "wb")
# Lay kich thuoc file
f1.seek(0, 2) size1 = f1.tell() f1.seek(0, 0)
while f1.tell() < size1: f2.write(f1.read( ))1 f1.close()
Thực hiện sao chép
Nội dung file gốc và file kết quả
Để sao chép nội dung file, ta tiến hành đọc nội dung từ file gốc lưu vào biến tạm, sau đó ghi nội dung này vào file đích.
Lệnh f1 = open(path1, "rb") mở file nguồn ở chế độ đọc nhị phân. Lệnh f2 = open(path2, "wb") để mở file đích ở chế độ ghi nhị phân.
Tương tự như ví dụ trên, ta tiến hành lấy kích thước file nguồn, sau đó thực hiện vòng lặp với điều kiện lặp là vị trí con trỏ chưa vượt quá kích thước file.
Lệnh f2.write(f1.read(1)) để trực tiếp ghi nội dung đọc từ file nguồn vào file đích. Kết thúc việc đọc ghi, ta tiến hành đóng file. Việc đóng file để tránh các thao tác lỗi sẽ làm ảnh hưởng nội dung file.
1.41. Thêm nội dung vào cuối file
path1 = input("Nhap duong dan file 1: ") path2 = input("Nhap duong dan file 2: ") f1 = open(path1, "rb")
f2 = open(path2, "a+b")
# Lay kich thuoc file