Đầu tiên, hãy đảm bảo rằng chúng ta sử dụng phiên bản Python 3. Không nên sử dụng Python 2 vì nó đã bị khai tử.
Python có nhiều kiểu dữ liệu khác nhau. Dưới đây là một số kiểu có sẵn trong Python. Khi các bạn làm việc với các thư viện khác, ta sẽ còn gặp thêm nhiều kiểu dữ liệu nữa.
x = 20
print(type(x))
Các thao tác toán học như cộng, trừ, nhân, chia, chia lấy phần nguyên, chia lấy phần dư, tính lũy thừa đều được hỗ trợ trong python.
x = 3
y = 5
print(x + y)
print(x - y)
print(x * y)
print(x / y)
print(x // y)
print(x % y)
print(x ** y)
x = 17.0
print(type(x))
Cũng giống như số nguyên. Các thao tác toán học như cộng, trừ, nhân, chia, chia lấy phần nguyên, chia lấy phần dư, tính lũy thừa đều được hỗ trợ trong python.
# Floats
x = 4.0
y = 2.5
print(x + y)
print(x - y)
print(x * y)
print(x / y)
print(x // y)
print(x % y)
print(x ** y)
Python có hỗ trợ kiểu dữ liệu logic (True, False) và các phép tính logic:
x = True
y = False
print(type(x))
print(x and y) # x and y
print(x or y) # x or y
print(not x)
Chuỗi là cấu trúc lưu dữ liệu dạng văn bản (như tin nhắn chẳng hạn). Một chuỗi có thể được gói giữa hai ký tự nháy kép ("string") hoặc nháy đơn ('string').
x = "PiMA 2021"
print(type(x))
print(x)
y = 'PiMA 2021'
print(type(y))
print(y)
Ta có thể nối chuỗi bằng phép cộng, hoặc nhân bản chuỗi bằng phép nhân.
x = "PiMA"
y = "2021"
print(x + y)
print(x + " " + y)
print(x * 3)
Lấy độ dài chuỗi: len()
x = "PiMA"
print(len(x))
Để "ép" một biến var từ kiểu type1 sang một kiểu dữ liệu khác type2 có thể làm cú pháp như sau: type2(var)
y = int(17.3)
print(y, type(y))
y = int(-17.3)
print(y, type(y))
y = float(3)
print(y, type(y))
Câu lệnh if dùng để kiểu khiển chương trình dựa trên một điều kiện cho trước. Ví dụ:
x = 2
y = 3
if x < y:
print("x nho hon y")
Ngoài phép so sánh <, ta còn có một số phép thông dụng sau:
x > y: x lớn hơn yx == y: x bằng y (lưu ý là == thay vì =) x >= y: x lớn hơn hoặc bằng yx <= y: x nhỏ hơn hoặc bằng yx != y: x khác yDo python sử dụng thụt lề để phân tách các khối lệnh, nên sau if ta phải thụt lề vào trong:
x = 2
y = 3
# lỗi
if x < y:
print("x nho hon y")
Đôi khi ta muốn xử lý trường hợp ngoại lệ (khi mà điều kiện if không đúng), ta có thể dùng thêm else:
x = 5
y = 3
if x < y:
print("x nho hon y")
else:
print("x khong nho hon y")
Ta có thể tiếp tục if sau else:
x = 5
y = 3
if x < y:
print("x nho hon y")
else:
if x > y:
print("x lon hon y")
else:
print("x bang y")
# rút ngắn bằng elif
x = 3
y = 3
if x < y:
print("x nho hon y")
elif x > y:
print("x lon hon y")
else:
print("x bang y")
Ta cũng có thể kết hợp nhiều điều kiện bằng các phép logic như and, or, not.
x = 3
y = 4
z = 5
if x < y and x < z:
print("x nho hon y va z")
if not x > y:
print("x khong lon hon y")
# In các số từ 5 tới 9
for i in range(5, 10, 1):
print(i)
print()
# step mặc định là 1
for i in range(5, 10):
print(i)
# In các số chẵn nhỏ hơn 10
for i in range(0, 10, 2):
print(i)
Ta cũng có thể kết hợp với lệnh if:
# In các số chẵn nhỏ hơn 10
for i in range(0, 10):
if i % 2 == 0:
print(i)
print()
# begin mặc định là 0
for i in range(10):
if i % 2 == 0:
print(i)
while¶Câu lệnh while có cú pháp while <conditions>: <statements>. Trong đó conditions có thể là một hoặc nhiều điều kiện ghép nhau bằng and, or, not. Ví dụ sau liệt kê các số chính phương nhỏ hơn 10.
i = 1
while (i**2 < 10):
print(i**2)
i += 1
Trong Python, khi nhóm các giá trị lại với nhau thành cụm sẽ gọi là tuple. Ví dụ như mỗi điểm trong không gian Oxyz được biểu diễn bằng ba giá trị $(x; y; z)$ có thể được biểu diễn dạng tuple.
point = (1, 2, 3)
print(type(point))
print(point)
len()point = (1, 2, 3)
print(len(point))
point = (1, 2, 3)
x, y, z = point # Lấy ra giá trị từ tuple
print(x, y, z)
Các phần tử trong tuple có thể được gọi dựa vào chỉ số (index) hay còn gọi là thứ tự của nó trong tuple. Trong một tuple, phần tử đầu tiên có chỉ số là 0.
point = (1, 2, 3)
print(point[0])
print(point[2])
Một tuple còn có thể được truy cập thông qua một chỉ số âm. Đối với chỉ số âm, phần tử cuối cùng trong tuple được đánh số -1, phần tử liền trước có chỉ số nhỏ hơn 1 đơn vị so với phần tử liền sau. Xem ví dụ:
x = (1, 2, 3)
print(x)
print(x[-1])
print(x[-2])
Lưu ý: khi truy cập phần tử nằm ngoài tuple sẽ gây ra lỗi
x = (1, 2, 3)
print(x[5])
print(x[-5])
Trong python, ta có thể dùng danh sách để chứa nhiều phần tử trong 1 biến.
x = [1, 2, 3, 4]
print(type(x))
Một danh sách có thể bao gồm danh sách khác (nested list), các phần tử của một danh sách có thể thuộc nhiều lớp dữ liệu khác nhau.
x = [[1, 2], [3, 4]] # Ma trận 2x2
x = [[1.0, 2], "xyz", [5, 6]]
print(type(x))
Các thao tác cơ bản cho danh sách bao gồm:
len)x = ['P', 'i', 'M', 'A']
print(len(x))
append)x = ['P', 'i', 'M', 'A']
print(x)
x.append(2021)
print(x)
Tương tự như tuple, ta có thể truy cập phần tử dựa vào chỉ số
x = ['P', 'i', 'M', 'A']
print(x[0])
print(x[-1])
print(x[-2])
insert)x = ['P', 'i', 'M', 'A']
x.insert(1, 123)
print(x)
pop)x = ['P', 'i', 'M', 'A']
x.pop(1)
print(x)
remove).x = ['P', 'i', 'M', 'A', 'i']
x.remove('i')
print(x)
Lưu ý: xóa phần tử không nằm trong danh sách sẽ gây ra lỗi
x = ['P', 'i', 'M', 'A']
x.remove(123) # lỗi
sort)x = [5, 1, 3, 2, 8]
x.sort()
print(x)
Đôi khi ta muốn duyệt qua hết các phần tử của danh sách. Ta có thể dùng câu lệnh for với cấu trúc: for <biến> in <danh_sách>: <khối lệnh>
x = ['P', 'i', 'M', 'A']
for ele in x:
print(ele)
Tuy nhiên, đôi khi ta cần chỉ số của phần tử thay vì chính nó. Dưới đây là một số cách để lấy chỉ số của phần tử:
x = ['P', 'i', 'M', 'A']
for i in range(len(x)):
print(i, "->", x[i])
enumerate. Hàm enumerate(x) sẽ trả về một danh sách các tuple, mỗi tuple gồm 2 thành phần là (i, x[i])x = ['P', 'i', 'M', 'A']
for ele in enumerate(x):
print(ele)
print()
for ele in enumerate(x):
print(ele[0], "->", ele[1])
print()
# Do phần tử trong enumerate là tuple
# nên ta có thể lấy giá trị của tuple theo cách này
for idx, ele in enumerate(x):
print(idx, "->", ele)
[begin : end : step].begin mặc định là 0, end mặc định là độ dài của list, step mặc định là 1.begin là số âm thì end mặc định là 0.end là số âm thì begin mặc định là -len(list).step là số âm thì mặc định begin = len(list)-1 và end = 0.Các bạn có thể thoải mái khám phá thử nghiệm về trò chơi cắt mảng này.
x = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(x[2:5])
print(x[:5])
print(x[5:])
print(x[::-1]) # đảo chiều danh sách
print(x[-3:])
print(x[:-4])
list¶Một list có thể được tạo nhanh thông qua dòng for (còn gọi là list comprehension). Chẳng hạn tạo một danh sách các số tự nhiên nhỏ hơn 10.
a = [x for x in range(10)]
print(a)
Tạo danh sách gồm bình phương của các số tự nhiên trong khoảng [4; 8]:
# list comprehension
a = [x * x for x in range(4, 9)]
print(a)
Ta cũng có thể tạo một danh sách mà chỉ gồm các phần tử thỏa mãn một tính chất nào đó. Ví dụ ta có thể lọc ra các số chẵn nằm trong 1 danh sách:
a = [2, 1, 3, 5, 6, 8, 10, 9]
b = [x for x in a if x % 2 == 0]
print(b)
Từ điển (dictionary) dùng để lưu dữ liệu dưới dạng "key-value" (khóa và giá trị). Quan hệ key-value giống với ánh xạ trong toán học.
x = {"P": "Project",
"i": "in",
"M": "Mathematics",
"A": "Applications"}
print(type(x))
print(x)
Khi gọi một phần tử trong danh sách ta dùng chỉ số của phần tử (e.g. x[5]). Tương tự trong từ điển, để tìm một giá trị (value) ta dùng khóa (key).
x = {"P": "Project",
"i": "in",
"M": "Mathematics",
"A": "Applications"}
print("M stands for", x["M"])
Để thêm một "định nghĩa" mới (một bộ key-value mới) ta có thể thoải mái "gán" (assign) mà không cần qua thao tác nào.
x = {"P": "Project",
"i": "in",
"M": "Mathematics",
"A": "Applications"}
# Nếu chưa có thì nó sẽ tạo
x["2016"] = "First PiMA camp"
print(x)
Ta có thể gán thoải mái những phần tử chưa tồn tại, tuy nhiên nếu truy cập phần tử chưa tồn tại thì sẽ gây lỗi:
x = {"P": "Project",
"i": "in",
"M": "Mathematics",
"A": "Applications"}
# Ta có thể gán phần tử chưa tồn tại, nhưng nếu truy cập nó thì sẽ gây ra lỗi
print(x[123])
x, ta có thể dùng hàm x.items(). Hàm này sẽ trả về danh sách các phần tử trong từ điển dưới dạng tuple 2 phần tử.x = {"P": "Project",
"i": "in",
"M": "Mathematics",
"A": "Applications"}
print(x.items())
for key, value in x.items():
print(key, "stands for", value)
pop(key)x = {"P": "Project",
"i": "in",
"M": "Mathematics",
"A": "Applications"}
x.pop("P")
print(x)
Tập hợp (set) dùng để lưu trữ các phần tử khác nhau và không có tính thứ tự.
x = {"P", "i", "M", "A"}
print(type(x))
print(x)
x = {"P", "i", "M", "A", "A"}
for ele in x:
print(ele)
add():x = {"P", "i", "M", "A"}
x.add("B")
print(x)
remove()x = {"P", "i", "M", "A"}
x.remove("A")
print(x)
x = {"P", "i", "M", "A"}
x.remove("B")
print(x)
So sánh danh sách, tuple, tập hợp, từ điển.
| Danh sách | Tuple | Tập hợp | Từ điển |
|---|---|---|---|
| Cho phép phần tử trùng nhau | Cho phép phần tử trùng nhau | Không cho phép phần tử trùng nhau | Các key không được trùng nhau |
| [1, 2, 3, 4, 5] | (1, 2, 3, 4, 5) | {1, 2, 3, 4, 5} | {1: "a", 2: "b", 3: "c"} |
| Mutable: Có thể thay đổi (thêm, xóa, sửa, ...) | Immutable: không thể thay đổi tuple khi đã khai báo | Mutable | Mutable |
| Có tính thứ tự | Có tính thứ tự | Không có tính thứ tự | Có tính thứ tự* (Python 3.6 trở về trước không có tính thứ tự) |
Để khai báo một hàm, dùng cú pháp:
def f(param1, param2=2):
return param1 + param2 * 0.5
Hàm f trên lấy hai tham số, trong đó tham số thứ hai (param2) có giá trị mặc định là 0. Lưu ý rằng các tham số có giá trị mặc định phải chuyển ra sau cùng trong danh sách tham số.
Các cách sử dụng hàm sau đây là hợp lệ:
print(f(1,2))
print(f(1))
print(f(param2 = 3, param1 = 2))
Như vậy khi gọi hàm, nếu không ghi rõ tên tham số truyền vào (cách 1, 2) thì các giá trị gán lần lượt cho các tham số theo thứ tự khi khai báo hàm. Nếu có ghi rõ (cách 3) thì không bắt buộc vị trí khai báo.
x = "PiMA 2021"
print(x[::-1])
print(x[:4])
print(x[5:])
x = "PiMA 2xxx"
x.replace("xxx", "021")
print(x)
print(x.replace("x", "021"))
x = x.replace("xxx", "021")
print(x)
x = "pImA"
print(x.upper())
print(x.lower())
x = " abc "
print(x.strip().replace(' ', '_'))
# Tương tự ta cũng có lstrip và rstrip
print(x.lstrip().replace(' ', '_'))
print(x.rstrip().replace(' ', '_'))
year = 2021
x = f"PiMA {year}"
print(x)
x = {"P": "Project",
"i": "in",
"M": "Mathematics",
"A": "Applications"}
for key, value in x.items():
print(f"{key} stands for {value}")
x = ["P", "i", "M", "A"]
y = ' '.join(x) # tạo chuỗi từ danh sách x và chèn khoảng trắng ở giữa
print(y)
x = ["P", "i", "M", "A"]
y = ''.join(x)
print(y)
x = ["P", "i", "M", "A"]
y = '---'.join(x)
print(y)
x = ["P", "i", "M", "A"]
y = '\n'.join(x) # tạo chuỗi từ danh sách x và chèn xuống dòng ở giữa
print(y)
x = "PIMA 2021"
print(x.split(' '))
x = "PIMA 2021"
print('_'.join(x.split(' ')))
var = input("Give me a value: ")
print(type(var))
print(var)
var = int(input("Give me an integer: "))
print(type(var))
print(var)
Hàm input chỉ có thể đọc trong một dòng mà thôi. Tức là nếu gặp ký tự '\n' thì hàm sẽ dừng và trả kết quả cho biến dạng chuỗi.
with open("file_io.dat", "w") as f:
f.write("Hello")
f.write("!\n")
f.write(f"This is PiMA {2021}")
Hàm write chỉ nhận tham số dạng chuỗi. Để viết các kiểu dữ liệu khác, xem lại phần format chuỗi.
with open("file_io.dat", "r") as f:
print(f.read())
x = "Name,NickName\nThuc,Ca Noc\nThe Anh,Nah"
print(x)
open("file_csv.csv", "w").write(x)
Dưới đây là mẫu đọc một file csv với các hàm xử lý xâu
with open("file_csv.csv", "r") as f:
lines = f.read().split('\n') # Đọc toàn bộ file f và tách thành từng dòng
headers = lines[0].split(',') # Dòng đầu tiên là header của cột
print(headers)
for line in lines[1:]: # Dùng slide để duyệt qua các dòng còn lại
name, nickname = line.split(',') # Cắt chuỗi dựa vào dấu ,
print(f"Name: {name}\nNickname: {nickname}")
Bài tập này nhằm làm quen với viết hàm và thao tác với chuỗi
def extract_odd_positions(x):
# Sửa code này
result = x
return result
print(extract_odd_positions([1, 2, 3, 4])) # [2, 4]
print(extract_odd_positions(["a", "b", "c", "d", "e"])) # ["b", "d"]
Cho một chuỗi có tên của một người (không có dấu cách). Hãy viết hoa ký tự đầu và viết thường các ký tự còn lại.
def uppercase_name(x):
# Sửa code này
result = x
return result
print(uppercase_name("pima")) # Pima
print(uppercase_name("pIMA")) # Pima
Cho một chuỗi có tên của một người. Hãy viết hoa tên người đó theo đúng định dạng
# Gợi ý: kết hợp hàm uppercase_name ở trên, hàm split và join
def uppercase_fullname(x):
# Sửa code này
result = x
return result
print(uppercase_fullname("nguyeN van a")) # Nguyen Van A
print(uppercase_fullname("projects in mathematics and aplications"))
Cho hai vector $x = (x_1, x_2)$ và $y = (y_1, y_2)$
Hình chiếu của x lên y, ký hiệu $\vec{x}^{*} = \text{proj}_{\vec{y}}(\vec{x})$. Biết: $$\vec{x}^{*} = \frac{\vec{x} \cdot \vec{y}}{||y||^2}\vec{y}$$
import math
# Hàm lấy căn bậc hai của x trong Python là: math.sqrt(x)
# dot product
def dot_product(x, y):
dot = None
return dot
# length of a vector x
def length(x):
l = None
return l
# cos between two vectors
def cos2v(x, y):
c = None
return c
def proj(x, y):
proj = None
return proj
print(dot_product((1, 2), (3, 4))) # 11
print(length((1, 2))) # 2.2360679775
print(cos2v((1, 2), (3, 4))) # 0.9838699101
print(proj((1, 2), (3, 4))) # (1.32, 1.76)
2.1. Cho D là bảng phân phối xác suất. D là một dictionary như sau:
D = {giá trị: xác suất ứng với giá trị đó}
Tính xác suất kỳ vọng ứng với bảng phân phối xác suất.
Nhắc lại: Cách để truy cập mọi từ khóa, giá trị ứng với từ khóa trong từ điển là:
for key, value in x.items():
print(key, value)
OPTIONAL 2.2. Cho hai ma trận A và B.
a) Kiểm tra nếu hai ma trận A và B cùng chiều
b) Tính $A + B$, $A - B$
c) Kiểm tra nếu có thể nhân ma trận A và B với nhau
d) Tính $A \times B$def expected_value(D):
exp_value = 0
return exp_value
D = {20: 0.2, 28: 0.2, 32: 0.4, 35: 0.2} # (ví dụ 3.10, tài liệu xác suất thống kê)
print(expected_value(D)) # 29.4
# kiểm tra A có thể nhân được với B hay không
def check_dim(A, B):
if_dim = False
return if_dim
def add(A, B):
s = None
return s
def sub(A, B):
s = None
return s
print(check_dim([[1, 2, 3], [4, 5, 6]], [[2, 3, 7], [4, 5, -3]])) # True
print(check_dim([[1, 2, 3], [4, 5, 6]], [[2], [4], [1]])) # True
print(add([[1, 2, 3], [4, 5, 6]], [[2, 3, 7], [4, 5, -3]]))
print(add([[1, 2, 3], [4, 5, 6]], [[2], [4], [1]]))
print(sub([[1, 2, 3], [4, 5, 6]], [[2, 3, 7], [4, 5, -3]]))
print(sub([[1, 2, 3], [4, 5, 6]], [[2], [4], [1]]))
# kiểm tra A có thể nhân được với B hay không
def check_prod(A, B):
if_prod = False
return if_prod
def matrix_prod(A, B):
prod = None
return prod
print(check_prod([[1, 2, 3], [4, 5, 6]], [[2, 3], [4, 5]])) # False
print(check_prod([[1, 2, 3], [4, 5, 6]], [[2], [4], [1]])) # True
print(matrix_prod([[1, 2, 3], [4, 5, 6]], [[2, 3], [4, 5]]))
print(matrix_prod([[1, 2, 3], [4, 5, 6]], [[2], [4], [1]]))
* Lớp (class)¶Class là chức năng quan trọng khiến Python trở thành ngôn ngữ lập trình hướng đối tượng. Mỗi biến trong Python dù lớn hay nhỏ (int) đều là một đối tượng (object). Trong một đối tượng chứa các thuộc tính (attribute) đóng vai trò như biến để cung cấp thêm thông tin về đối tượng đó, và các phương pháp (method) đóng vai trò như hàm để thực thi một loạt các lệnh xử lý.
Ví dụ khi mô hình hóa xe cứu thương vào lập trình, có thể biến nó thành một object với kiểu dữ liệu tên Ambulance được định nghĩa qua lớp cùng tên. Xe cứu thương có thể bao gồm các thông số như biển số xe (string) và vị trí hiện tại của xe (dựa theo mã tỉnh, int). Thao tác có thể đặt bên trong đối tượng này là "di chuyển đến" để hỗ trợ một xe cứu thương khác.
class Ambulance:
def __init__(self, plate, city):
self.plate = plate
self.city = city
def assist(self, another_ambulance):
self.city = another_ambulance.city
def __str__(self):
return "Ambulance {0} is in city {1}"\
.format(self.plate, self.city)
Lưu ý rằng trong mỗi class thường có hàm __init__ để khởi tạo một đối tượng. Trong ví dụ trên, hàm này có nhận tham số plate và gán vào self.plate. Có thể hình dung rằng self.plate là một biến plate là một thuộc tính (hay biến) thuộc lớp Ambulance, còn tham số plate được truyền vào hàm __init__ là một biến độc lập chỉ có giá trị trong hàm này chứ không thuộc lớp Ambulance. Hàm __str__ dùng để hướng dẫn cho câu lệnh print nên in ra thông tin gì khi người ta cố gắng in đối tượng này ra màn hình.
Mọi hàm trong class đều phải có tham số self. Khi gọi hàm thuộc class không truyền giá trị vào tham số này.
amb1 = Ambulance("65-B1-2019", 32)
amb2 = Ambulance("50-B2-11124", 14)
print(amb1)
print(amb2)
amb2.assist(amb1)
print(amb2)