Category: Khám phá

1. Kiến thức lập trình

• Lập trình hướng đối tượng với python
• Lập trình game với thư viện pygame
• Vòng lặp, câu điều kiện trong python
• Một số yếu tố toán học và hình học để lập trình game

2. Giới thiệu trò chơi

Bóng bàn là một trong những môn thể thao phổ biến trên toàn thế giới và điều đó cũng biến game ping pong trở thành một trong những game máy tính đầu tiên được ra đời vào năm 1972. Trò chơi có quy tắc chơi rất là đơn giản. Hai bên sẽ đỡ trả những quả bóng cho đến khi một bên không đánh trả được nữa. Ở đây chúng ta sẽ là một người chơi và đánh quả bóng bàn không bị rơi xuống đất. Các bạn học sinh hãy cùng trải nghiệm trò chơi trước khi bắt tay vào lập trình ở link sau: https://replit.com/@STEAM4VNOfficial/Pingpong#main.py 

3. Bắt tay vào lập trình thôi nào

Bước 1: Khai báo thư viện sử dụng để lập trình trò chơi

Giống như các bài blog khác trong Pygame series (Link), chúng ta sẽ cần sử dụng thư viện pygame. Ngoài ra, chúng ta cũng cần có thư viện random để khởi tạo ngẫu nhiên hướng đi của quả bóng bàn khi mới bắt đầu trò chơi.

import pygame
import random

Bước 2: Khởi tạo một vài yếu tố cơ bản của trò chơi:

Hàm pygame.init() giúp chúng ta bắt đầu khởi tạo trò chơi. Thêm vào đó, các  bạn hãy sử dụng vòng lặp while với biến start để lặp lại liên tục các hành động của người chơi và quả bóng, cho đến khi quả bóng rơi xuống đất. Biến start sẽ được khởi tạo với giá trị True. Khi bóng rơi xuống đất, biến start sẽ được thay đổi thành False. 

Chúng ta cũng cần khởi tạo một số màu cơ bản dùng trong trò chơi, cho quả bóng, vợt bóng bàn, và màn hình. Giống như blog cờ caro (link), chúng ta sẽ sử dụng bảng mã RGB.

Black = (0,0,0)
Green = (0, 250, 0)
Yellow = (250, 250, 0) 

Sau đó, các bạn tiếp tục khởi tạo màn hình cửa sổ trò chơi với kích thước 800×500 pixels bằng câu lệnh pygame.display.set_mode. Chúng ta cũng cài đặt màn hình màu đen bằng câu lệnh fill. Ngoài ra, câu lệnh pygame.display.set_caption sẽ giúp hiển thị tên của trò chơi. 

screen = pygame.display.set_mode((800, 500))
screen.fill(Black)
pygame.display.set_caption('Ping Pong')

Tương tự như game cờ caro, chúng ta sẽ sử dụng font freesansbold với kích thước 20 cho chữ trong game. Đồng thời, ta sử dụng thư viện random để khởi tạo chọn ngẫu nhiên một trong hai số 0 và 1, ứng với hướng di chuyển của quả bóng lúc bắt đầu trò chơi. Để cho game thêm phần thú vị, chúng ta sẽ tính điểm của người chơi và lưu vào biến score. Biến score sẽ được khởi tạo bằng 0: 

direct = random.randint(0,1)
font = pygame.font.Font('freesansbold.ttf', 20)
score = 0

Bước 3: Khởi tạo 2 đối tượng chính của người chơi là quả bóng và trò chơi. 

Chúng ta sẽ sử dụng khái niệm đối tượng và lớp đã được học ở bài 8 của khoá CS 101 để tạo quả bóng và người chơi. Chúng ta sẽ tạo lớp (class) Player với hai thuộc tính x và y, để lưu toạ độ của người chơi. Sau đó chúng ta sẽ tạo đối tượng (object) player của lớp Player để tạo một người chơi trong trò chơi. Trong trường hợp này người chơi sẽ là cái vợt bóng bàn ở vị trí (400,200) trên màn hình trò chơi khi bắt đầu.

Tương tự như vậy, chúng ta sẽ tạo lớp Ball và đối tượng ball để tạo một quả bóng ở vị trí (350,400) cho trò chơi. Vì chúng ta sử dụng khái niệm lập trình hướng đối tượng nên chúng ta có thể tạo ra rất nhiều người chơi và quả bóng khác nhau. Tất cả người chơi và quả bóng đều có hai thuộc tính là toạ độ x, y.

class Player:
    def __init__(self, x, y):
        self.x = x
        self.y = y
class Ball:
    def __init__(self, x, y):
        self.x = x
        self.y = y
 
ball = Ball(400, 200)
player = Player(350, 400)

Bước 4: Vẽ các yếu tố đồ hoạ lúc bắt đầu game

Trong trò chơi này, quả bóng sẽ là hình tròn, người chơi và mặt đất sẽ là hình chữ nhật. Chúng ta sẽ bắt đầu với câu lệnh pygame.display.flip(). Để vẽ hình tròn, ta sẽ sử dụng câu lệnh pygame.draw.circle() với 4 inputs: màn hình game (screen), màu sắc, toạ độ của tâm hình tròn, và bán kính của hình tròn. Toạ độ của tâm hình tròn sẽ là 2 thuộc tính x và y của đối tượng ball. Chúng ta sẽ lấy thuộc tính của đối tượng bằng câu lệnh đã học ở bài 8 của khoá CS 101. Bán kính của quả bóng là 20 và quả bóng màu xanh lá cây.

Để vẽ hình chữ nhật, chúng ta sẽ sử dụng câu lệnh pygame.draw.rect() với 3 inputs: màn hình, màu sắc, và đối tượng hình chữ nhật trong pygame. Đối tượng hình chữ nhật được định nghĩa bởi câu lệnh pygame.Rect() với 4 inputs. Hai inputs đầu tiên xác định toạ độ của đỉnh bên trái trên cùng của hình chữ nhật. Input thứ ba là chiều dài của hình chữ nhật. Input thứ tư là chiều rộng của hình chữ nhật. Ví dụ, hình chữ nhật biểu diễn người chơi có chiều dài là 100 và chiều rộng là 20. Ngoài ra, toạ độ của đỉnh trên cùng bên trái được xác định bằng thuộc tính x, y của đối tượng player. Chúng ta sẽ vẽ hình chữ nhật biểu diễn người chơi bằng màu vàng và hình chữ nhật biểu diễn mặt đất bằng màu đỏ.  

    pygame.display.flip() #DRAW AND UPDATE
    screen.fill(Black)
    pygame.draw.rect(screen, Yellow, pygame.Rect(player.x , player.y, 100, 20))
    pygame.draw.circle(screen, Green, (ball.x, ball.y), 20)
    pygame.draw.rect(screen, (250,0,0), pygame.Rect(0, 480, 800, 500))

Điểm số được đặt ở vị trí (50,20) trên màn hình game. Chúng ta sẽ sử dụng câu lệnh screen.blit().

  scoretext = font.render("Score: " + str(score) , True, (0,250,250))
    textRect = scoretext.get_rect()
    textRect.center = (50, 20)
    screen.blit(scoretext, textRect)

Ngoài ra, chúng ta sẽ sử dụng vòng lặp for để đi qua tất cả các tương tác của người dùng với trò chơi, và đóng game khi người dùng ấn vào nút đóng. Chúng ta cũng định nghĩa biến move để lấy ra nút người chơi bấm trên bàn phím để di chuyển hình chữ nhật màu vàng.

for event in pygame.event.get(): 
        if event.type == pygame.QUIT:
            pygame.quit()
move = pygame.key.get_pressed()

• Bước 5: Code phần di chuyển của người chơi

Người chơi sẽ có 2 hướng di chuyển: sang trái hoặc sang phải. Khi người chơi ấn nút sang trái, toạ độ x của người chơi sẽ giảm đi 0.5. Khi người chơi ấn nút sang phải, toạ độ x sẽ tăng thêm 0.5. Toạ độ x sẽ bằng 0 nếu người chơi đi ra khỏi góc trái màn hình (x < 0). Toạ độ x sẽ bằng 700 nếu người chơi đi ra khỏi góc phải màn hình (x > 700). 

if move[pygame.K_LEFT]: 
        player.x -= 0.5
        if player.x < 0:
            player.x = 0
    elif move[pygame.K_RIGHT]:
        player.x += 0.5
        if player.x > 700:
            player.x = 700

• Bước 6: Code phần di chuyển quả bóng:

Chúng ta quy định hướng di chuyển của quả bóng bằng các chỉ số như hình vẽ trên. Bây giờ chúng ta sẽ nhận xét và vẽ hình khi mà quả bóng va chạm với các cạnh với các hướng thì nó sẽ thay đổi sao. Khi mà quả bóng va vào người chơi hay va vào bức tường thì quả bóng sẽ bật lại theo hướng ngược với nó va chạm vào.

Hướng 0 là hướng đi lên trên bên trái. Khi đi theo hướng này, toạ độ x và y của quả bóng đều bị giảm đi 0.4. Vì quả bóng có bán kính 20 nên khi toạ độ tâm của quả bóng bé hơn 20 ở x thì quả bóng đã va vào bức tường bên trái và bị bật lại theo hướng 1. Tương tự, khi toạ độ y bé hơn 20, quả bóng va vào bức tường ở trên và bật lại theo hướng 3. Hướng 1 là hướng đi lên bên phải. Hướng 3 là hướng đi xuống bên trái. Khi bóng đi theo hướng 1, toạ độ x được thêm 0.4 và toạ độ y bị trừ đi 0.4. Vì màn hình có kích thước 800 theo chiều x và quả bóng có bán kính 20 nên khi bóng đi theo hướng 1, nếu toạ độ x lớn hơn 780, bóng đã va vào bức tường bên phải. Bóng sẽ bật ra theo hướng 0. Tương tự, nếu toạ độ y của quả bóng bé hơn 20, bóng đã va vào bức tường ở trên và bật ra theo hướng 2. Khi bắt đầu trò chơi, quả bóng sẽ được ngẫu nhiên chọn di chuyển theo hướng 0 hoặc hướng 1.            

       # BALL
    if direct == 0: # LEFT UP
        ball.x -= 0.4
        ball.y -= 0.4
        if ball.x < 20:
            direct = 1
        if ball.y < 20:
            direct = 3
    if direct == 1: # RIGHT UP
        ball.x += 0.4
        ball.y -= 0.4
        if ball.x > 780:
            direct = 0
        if ball.y < 20:
            direct = 2

Hướng 2 là hướng đi xuống bên phải. Khi quả bóng đi theo hướng này, toạ độ x và y được cộng thêm 0.4. Nếu quả bóng va vào cạnh dưới và ở vị trí người chơi thì họ sẽ được cộng điểm, còn không họ sẽ thua. Để kiểm tra điều kiện này, chúng ta có thể sử dụng câu lệnh điều kiện if và phép toán and để kết hợp nhiều điều kiện. Chúng ta có thể dễ dàng đặt các điều kiện với lưu ý là quả bóng có bán kính 20 và hình chữ nhật biểu diễn người chơi có chiều dài là 100. Khi quả bóng ở vị trí người chơi, điểm sẽ được cộng 1 và quả bóng bật lại theo hướng 1. Ngoài ra chúng ta phải kiểm tra xem quả bóng có va vào bức tường bên phải chưa. Nếu quả bóng va vào bức tường bên phải, quả bóng sẽ bật lại theo hướng 3 là hướng đi xuống bên trái. Tương tự, chúng ta có trường hợp quả bóng theo hướng 3. Ngoài ra, người chơi sẽ thua khi quả bóng chạm đất. Vì chiều rộng của màn hình trò chơi là 500 nên khi toạ độ y của tâm quả bóng ở 480, biến start sẽ chuyển sang False và người chơi đã thua.      

    if direct == 2: # RIGHT DOWN
        ball.x += 0.4
        ball.y += 0.4
        if ball.y >= player.y - 20 and ball.y <= player.y + 20 and ball.x >= player.x and ball.x <= player.x + 100:
            direct = 1
            score += 1
        if ball.x > 780:
            direct = 3
    if direct == 3: # LEFT DOWN
        ball.x -= 0.4
        ball.y += 0.4
        if ball.y >= player.y - 20 and ball.y <= player.y + 20 and ball.x >= player.x and ball.x <= player.x + 100:
            direct = 0
            score += 1
        if ball.x < 20:
            direct = 2
    if ball.y >= 480:
        start = False

• Bước 7: Hoàn thiện phần kết thúc trò chơi:

Phần kết thúc trò chơi sẽ có màn hình màu trắng và có chữ You Lose cùng với điểm số. Chúng ta có thể sử dụng các câu lệnh font.render, screen.blit, text.get_rect tương tự game cờ caro (link) để in thông báo ra màn hình. Đồng thời sử dụng câu lệnh pygame.quit() để kết thúc trò chơi.

screen.fill((250,250,250))
font = pygame.font.Font('freesansbold.ttf', 40)
text = font.render("You Lose :))", True, (250,0,0))
textRect = text.get_rect()
textRect.center = (400, 250)
screen.blit(text, textRect)
text = font.render("Score: " + str(score), True, (0,100,250))
textRect = text.get_rect()
textRect.center = (400, 300)
screen.blit(text, textRect)
pygame.display.flip()
pygame.time.delay(6000)

      pygame.quit()

4. Tadaa!!!

Trò chơi ping pong này thật thú vị phải không các bạn! Sau khi hoàn thành trò chơi, chúng ta đồng thời đã áp dụng được ngay các kiến thức lập trình với pygame, kiến thức toán và kiến thức vật lý về phản xạ của quả bóng khi đập vào tường. Các bạn học sinh hãy thử sáng tạo và cải tiến code bằng cách áp dụng các định luật vật lý về phản xạ như định luật Snell (học ở chương trình vật lý 7) để có thể tạo được hiệu ứng bật lại của quả bóng đúng hơn. Ngoài ra, các bạn có thể tạo thêm người chơi, thêm quả bóng cho trò chơi nhé. 

Sau khi hoàn thành dự án cá nhân, các bạn đừng quên chia sẻ chương trình của mình lên STEAMese Profile để thầy cô và các bạn cùng trải nghiệm và nhận xét. 

— — —

STEAM for Vietnam Foundation là tổ chức phi lợi nhuận 501(c)(3) được thành lập tại Hoa Kỳ với sứ mệnh thúc đẩy các hoạt động liên quan tới giáo dục STEAM (Science — Khoa học, Technology — Công nghệ, Engineering — Kỹ thuật, Arts — Nghệ thuật, Mathematics — Toán học) tại Việt nam. STEAM for Vietnam được thành lập và vận hành bởi đội ngũ tình nguyện viên là du học sinh và chuyên gia người Việt trên khắp thế giới.

— — —

📧Email: hello@steamforvietnam.org

🌐Website: www.steamforvietnam.org

🌐Fanpage: STEAM for Vietnam

📺YouTube:  http://bit.ly/S4V_YT

🌐Zalo: Zalo Official

Các bạn có thể xem lại phần 1 ở đây

1. Kiến thức lập trình

• Lập trình game với thư viện pygame
• Câu điều kiện
• Mảng 2 chiều trong python
• Vòng lặp trong python
• Hàm trong python
• Một số mã RGB của các màu cơ bản

2. Giới thiệu trò chơi

Các bạn học sinh hẳn đã rất quen thuộc với trò chơi caro truyền thống. Cách chơi trò này rất đơn giản, 2 người chơi đại diện cho 2 quân X và O. Mỗi lượt đi, người chơi lần lượt đánh quân của họ lên bàn cờ. Trò chơi chỉ xác định người thắng bại khi mà có 5 quân cờ của họ cùng nằm liên tiếp trên một hàng ngang hoặc một hàng dọc hoặc một đường chéo.

Trước tiên các bạn hãy chơi thử game nhé! https://replit.com/@STEAM4VNOfficial/Caro  

3. Bắt tay vào lập trình thôi nào!

a. Thuật toán

Chúng ta sẽ chọn một bảng kích cỡ khá lớn để bắt đầu. Ở đây các bạn học sinh hãy chọn bảng 33×64 là dễ nhìn và tiện thao tác nhất. 

Bảng ở đây sẽ biểu diễn dưới dạng mảng 2 chiều. Mỗi khi chúng ta click chuột vào một ô để đánh dấu thì sẽ xem lại cả bảng để kiểm tra các điều kiện về đường dọc, đường ngang, đường chéo. Khi đó các bạn sẽ biết được mình có chiến thắng không. Không chỉ vậy, các bạn sẽ dùng vòng lặp để đếm các ô trong mảng 2 chiều, chỉ khi nào mà 5 ô cùng màu được tô liên tiếp theo hàng dọc hoặc hàng ngang hoặc hàng chéo chúng ta sẽ in ra kết quả người chơi chiến thắng.

Nếu có người thắng cuối, trò chơi sẽ in ra kết quả người thắng cuộc và kết thúc trò chơi, còn không, trò chơi vẫn tiếp tục. Nếu trong trường hợp 2 người chơi đã tô hết cả bảng mà vẫn không xác định trò chơi, máy sẽ thông báo kết quả hòa và kết thúc trò chơi.

b. Các bước triển khai dự án

Bước 1: Khai báo thư viện sử dụng để code trò chơi. 

Ở đây ngoài các hàm tiêu chuẩn có sẵn của ngôn ngữ lập trình python ra, ta sẽ sử dụng thêm 2 thư viện đó là pygame và sys. Thư viện pygame là một thư viện python giúp chúng ta có thể code các trò chơi dễ dàng hơn. Còn thư viện sys liên quan đến điều khiển các chương trình trên máy tính. Để khai báo chương trình, ta dùng 2 câu lệnh sau.

import pygame
import sys

Bước 2: Khai báo một số yếu tố cơ bản trong trò chơi

Đầu tiên, chúng ta sẽ định nghĩa một số màu hiển thị trong trò chơi theo bảng mã RGB. 

BLACK = (0, 0, 0)
WHITE = (255, 255, 255)
GREEN = (0, 255, 0)
RED = (255, 0, 0)
BLUE = (0,0,255)

Trong bảng mã RGB, mỗi một màu sẽ được biểu diễn bằng 3 phần tử tương ứng cường độ của 3 màu cơ bản: đỏ (Red), xanh lá (Green), xanh dương (Blue). Hoà trộn 3 màu này lại, chúng ta sẽ được một màu mới.    

Ta sẽ giả định con x là con đi trước và khởi tạo FPS – Frames Per Second (độ mượt của game) là 120

XO = 'x'
FPS = 120

Tiếp đó, chúng ta sẽ khởi tạo các kích cỡ bảng và ô caro. Biến WIDTH và HEIGHT chỉ chiều dài và chiều rộng mỗi ô caro là 28×28. Biến MARGIN chỉ độ dày cạnh mỗi ô caro là 2. Biến rownum và colnum lần lượt là số hàng và số cột của bảng caro. Chúng ta có 33 hàng và 64 cột.

# This sets the WIDTH and HEIGHT of each board location

WIDTH = 28
HEIGHT = 28
# This sets the distance between each cell
MARGIN = 2
rownum = 33
colnum = 64

Các bạn học sinh hãy biểu bảng caro dưới dạng mảng 2 chiều với rownum hàng và colnum cột. Đầu tiên khởi tạo grid là một mảng đơn. Sau đó, chúng ta dùng vòng lặp với số lần lặp tương ứng với số hàng (rownum) để khởi tạo mỗi phần tử của grid là một mảng, ứng với một hàng trong bảng caro. Chúng ta tiếp tục sử dụng vòng lặp thứ hai với số lần lặp tương ứng với số cột (colnum). Chúng ta sử dụng 2 vòng lặp để tạo một mảng hai chiều, giống như bảng caro hoặc mê cung trong bài 6 của khoá CS 101. Giá trị ở mỗi vị trí trong bảng là 0. Vậy là các bạn học sinh đã khởi tạo được bảng caro với kích cỡ rownum * colnum rồi đấy!

# Create a 2 dimensional array. A two dimensional
# array is simply a list of lists.
grid = []
for row in range(rownum):
    # Add an empty array that will hold each cell
    # in this row
    grid.append([])
    for column in range(colnum):
        grid[row].append(0)  # Append a cell

Giờ thì các bạn phải khởi tạo trò chơi. Muốn chạy một trò chơi thì trước tiên các bạn hãy dùng hàm pygame.init(). Ngoài ra để game hiển thị chúng ta phải khởi tạo về cửa sổ game: Biến WINDOW_SIZE chứa 2 kích cỡ chiều dài và chiều rộng của màn hình game ở đây sẽ để kích cỡ là 1920 * 990. Khi đó, biến screen chính là màn hình game trong python. Chúng ta sẽ khởi tạo nó bằng cách khai báo screen = pygame.display.set_mode(WINDOW_SIZE). Vậy chúng ta đã khởi tạo xong cửa sổ game với kích cỡ chúng ta yêu cầu. 

# Set the HEIGHT and WIDTH of the screen
WINDOW_SIZE = [1920,990]
screen = pygame.display.set_mode(WINDOW_SIZE)

Về yếu tố hình ảnh, chúng ta có hình ảnh quân X và quân O trên bàn cờ. Ở đây, chúng ta chuẩn bị hình ảnh quân X là file ảnh X_modified-100×100.png và quân O là o_modified-100×100.png. (Các bạn học sinh có thể lấy hình ở link). Sau đó, ta sẽ đưa hai hình ảnh đó vào trò chơi bằng các câu lệnh sau:

x_img = pygame.transform.smoothscale(pygame.image.load("X_modified-100x100.png").convert(),(28,28))
o_img = pygame.transform.smoothscale(pygame.image.load("o_modified-100x100.png").convert(),(28,28))

Ở đây, ta có thể thấy hàm pygame.transform.smoothscale chính là hàm giúp chúng ta chuyển đổi các hình ảnh thành các phần tử ta muốn trong game. Còn hàm pygame.image.load() sẽ đưa hình ảnh vào. Hàm convert() sẽ giúp ta chuyển hình ảnh thành các ô pixel. Và cuối cùng (28,28) chính là kích cỡ một ô vuông trong bảng caro ta đã nói ở trên.

Bước 3: Viết hàm kiểm tra điều kiện thắng của trò chơi

Làm thế nào để các bạn học sinh có thể biết trò chơi kết thúc và kết quả người chiến thắng?

Như các bạn đã biết, trò chơi chỉ có người chiến thắng khi tồn tại 5 quân cùng loại cùng nằm trên một hàng ngang hoặc một hàng dọc hoặc một đường chéo. Vậy trên một bảng, điều kiện đó sẽ được biểu diễn như thế nào?

Chúng ta gọi ô (i, j) là ô có địa chỉ tại hàng thứ i và cột thứ j. Khi đó, ta giả sử ô (i, j) là ô bắt đầu hàng ngang thì các ô tiếp theo của hàng ngang đó sẽ là (i, j + 1), (i, j + 2), (i, j + 3), (i, j + 4). Nếu ô đó là ô bắt đầu một hàng dọc thì các ô tiếp theo sẽ là (i + 1,j), (i + 2, j), (i + 3, j), (i + 4, j). Chúng ta có 2 loại đường chéo. Với loại đường chéo thứ nhất thì các ô tiếp theo sẽ là (i + 1, j – 1), (i + 2, j – 2), (i + 3, j – 3), (i + 4, j – 4). Còn lại với loại đường chéo thứ 2 thì là (i + 1, j + 1), (i + 2, j + 2), (i + 3, j + 3), (i + 4, j + 4). Chúng ta đã được học cách để lấy địa chỉ cho một ô trong mảng hai chiều ở bài 6 trong khoá CS 101. 

Như vậy để kiểm tra điều kiện thắng thì ta có thể kiểm tra các ô cùng hàng, cùng cột, cùng đường chéo một cách dễ dàng hơn. Ta có hàm kiểm tra như sau:

def checkwin(board):
    indices = [i for i,x in enumerate(board) if 'x' in x]
    for index in indices:
        xrowindices = [i for i, x in enumerate(board[index]) if x == "x"]
        for xs in xrowindices:
            if xs<=len(board[0])-5:
                if board[index][xs] == board[index][xs+1] == board[index][xs+2] == board[index][xs+3] == board[index][xs+4]:
                    return 1
            if index<=len(board)-5:
                if board[index][xs] == board[index+1][xs] == board[index+2][xs] == board[index+3][xs] == board[index+4][xs]:
                    return 1
                if xs<=len(board[0])-5:
                    if board[index][xs] == board[index+1][xs+1] == board[index+2][xs+2] == board[index+3][xs+3] == board[index+4][xs+4]:
                        return 1
                    if board[index][xs] == board[index+1][xs-1] == board[index+2][xs-2] == board[index+3][xs-3] == board[index+4][xs-4]:
                        return 1
    indices1 = [i for i,x in enumerate(board) if 'o' in x]
    for index1 in indices1:
        orowindices = [i for i, x in enumerate(board[index1]) if x == "o"]
        for os in orowindices:
            if os<=len(board[0])-5:
                if board[index1][os] == board[index1][os+1] == board[index1][os+2] == board[index1][os+3] == board[index1][os+4]:
                    return 2
            if index1<=len(board)-5:
                if board[index1][os] == board[index1+1][os] == board[index1+2][os] == board[index1+3][os] == board[index1+4][os]:
                    return 2
                if os<=len(board[0])-5:
                    if board[index1][os] == board[index1+1][os+1] == board[index1+2][os+2] == board[index1+3][os+3] == board[index1+4][os+4]:
                        return 2
                    if board[index1][os] == board[index1+1][os-1] == board[index1+2][os-2] == board[index1+3][os-3] == board[index1+4][os-4]:
                        return 2
    count = 0
    for rows in board:
        for cells in rows:
            if cells == 'x' or cells == 'o':
                count+=1
            if count == rownum*colnum:
                return 3
     return 0

Về cách đoạn code hoạt động, ta sẽ tách rõ ra làm 3 điều kiện kiểm tra. Phần thứ nhất là kiểm tra điều kiện thắng của con X, phần thứ 2 kiểm tra điều kiện thắng của con O và phần còn lại sẽ giúp chúng ta kiểm tra hai người chơi hòa hay không. Chúng ta sẽ đặt nếu người chơi X thắng thì trả kết quả chương trình về 1. Nếu người chơi O thắng sẽ trả kết quả về 2. Nếu giải đấu caro hòa thì về giá trị 3. Còn nếu trò chơi tiếp tục chúng ta trả về giá trị 0.

Các bạn có thể thấy ở đoạn code trên có một cách tạo mảng theo điểu kiện rất hay như sau:

 indices = [i for i,x in enumerate(board) if 'x' in x]

Cách tạo mảng trên được gọi là list comprehension và cấu trúc của nó như sau: 

newlist = [expression for value in array if true]

Cách tạo mảng này sẽ giúp chúng ta tạo một mảng mới từ mảng cũ bằng cách dựa vào các giá trị mảng cũ theo điều kiện nào đó. Các bạn có thể để ý hàm enumerate() sẽ giúp chúng ta tạo ra một danh sách gồm các cặp chỉ số – phần tử trong mảng như kiểu 0 – board [0] rất thuận tiện. Trong đoạn code này, ta sẽ thấy mảng indices chứa các chỉ số hàng của mảng board tồn các con X, tương tự với mảng indices1 sẽ chứa các chỉ số hàng của mảng board tồn tại các con O. 

Các bạn học sinh hãy để ý hai đoạn code kiểm tra điều kiện thắng của X và O. Ở vòng lặp thứ hai, chúng ta lại bắt gặp cách tạo mảng tương tự như vậy. Mảng thứ hai sẽ giúp chúng ta lấy chỉ số cột của các ô trong hàng index.

Ngoài việc kiểm tra các hàng, các cột, các đường chéo, trước hết chúng ta cần đảm bảo các ô chúng ta kiểm tra không bị vượt ra ngoài mảng 2 chiều. Nếu không, chương trình sẽ bị lỗi. Như khi kiểm tra một hàng, chúng ta phải kiểm tra đúng  xs <= len(board[0]) – 5 để xem các ô chúng ta kiểm tra sau đó có bị tràn ra khỏi bảng caro không. Các bạn nhớ chú ý khi kiểm tra một đường chéo thỏa mãn thì phải xem chỉ số hàng, cột và ô bắt đầu để có thể kiểm tra được cả 5 ô. 

Về phần kiểm tra người chơi hòa, các bạn hãy xem các ô tô X hoặc O hết chưa. Nếu có thì trò chơi hòa. Còn nếu không trò chơi tiếp tục

Bước 4: hoàn thiện các phần còn lại để trò chơi chạy

Đầu tiên, chúng ta sẽ khởi tạo hai biến là done và status để thể hiện trò chơi “đã kết thúc” và  “đã có người chiến thắng”. Ban đầu, chúng ta để hai biến này là False và None tại vì trò chơi chưa kết thúc và chưa xác định kết quả trò chơi.

# Loop until the user clicks the close button.
done = False
status = None

Sau đó, các bạn sẽ dùng một vòng lặp while để chạy trò chơi. Nếu mà biến done chưa đúng thì nghĩa là trò chơi vẫn tiếp tục và vòng lặp vẫn chạy. Trong pygame, các hoạt động của người chơi sẽ là các event. Chúng ta sẽ dùng một vòng lặp để lấy các event mà chúng ta tác động lên trò chơi. 

Trong đó, nếu mà chúng ta kết thúc trò chơi tức là loại event chúng ta thực hiện sẽ là pygame. QUIT thì pygame sẽ kết thúc và chúng ta sẽ để biến done là True để kết thúc vòng lặp. Còn nếu chúng ta click chuột vào một ô trên màn hình thì thao tác này là pygame .MOUSEBUTTONDOWN tức là người chơi chọn đánh dấu một quân lên bảng và chúng ta sẽ dùng hàm pygame.mouse.get_pos() để lấy vị trí ô chúng ta click vào. Nếu ô đó đã được đánh dấu là X hoặc O thì chúng ta bỏ qua. Còn không, chúng ta sẽ đánh dấu nó là biến xo và đổi biến xo ngược lại để đến lượt người chơi thứ hai. Sau đó, chúng ta sẽ gắn biến status với giá trị của hàm checkwin(grid).

while not done:
    for event in pygame.event.get():  # User did something
        if event.type == pygame.QUIT:  # If user clicked close
            done = True  # Flag that we are done so we exit this loop
            # Set the screen background
        if event.type == pygame.MOUSEBUTTONDOWN:
            pos = pygame.mouse.get_pos()
            col = pos[0] // (WIDTH + MARGIN)
            row=  pos[1] // (HEIGHT + MARGIN)
            if grid[row][col] == 0:
                if XO == 'x':
                    grid[row][col] = XO
                    XO = 'o'
                else:
                    grid[row][col] = XO
                    XO = 'x'
            status = checkwin(grid)

Ở đoạn code trên, các bạn có thể thấy chỉ số hàng và cột mà chúng ta lấy đã bị đảo lại. Nguyên nhân là vì hàm python.mouse.get_pos() sẽ trả về cột trước hàng sau..  

Trong vòng lặp while trên, sau khi đánh dấu ô và kiểm tra điều kiện chiến thắng, giờ chúng ta sẽ vẽ hình bảng caro. Đầu tiên, chúng ta sẽ để cả cái bảng màu đen. Sau đó, vẽ các ô caro là các hình vuông màu trắng có kích cỡ WIDTH * HEIGHT có khoảng cách là MARGIN. Như vậy, chúng ta đã xong bảng ô vuông caro. Giờ các bạn hãy dùng vòng lặp để xem ô đó có điền X hay O thì chúng ta chèn hình ảnh X hoặc O vào ô nhé! Ta có đoạn code sau:

for row in range(rownum):
        for column in range(colnum):
            color = WHITE
            pygame.draw.rect(screen,
                             color,
                              [(MARGIN + WIDTH) * column + MARGIN,
                              (MARGIN + HEIGHT) * row + MARGIN,
                              WIDTH,
                              HEIGHT])
            if grid[row][column] == 'x': 
                screen.blit(x_img,((WIDTH + MARGIN)*column+2,(HEIGHT + MARGIN)*row+2))
            if grid[row][column] == 'o':
                screen.blit(o_img,((WIDTH + MARGIN)*column+2,(HEIGHT + MARGIN)*row+2))

Ở đây, chúng ta thấy tọa độ một ô vuông màu trắng ứng với ô row, column sẽ là (MARGIN + WIDTH) * column + MARGIN, (MARGIN + HEIGHT) * row. Các bạn hãy vẽ hình vuông kích cỡ WIDTH * HEIGHT. Để ý kỹ, các bạn sẽ thấy chúng ta vẽ theo thứ tự cột trước hàng sau tại vì pygame sẽ vẽ hình chữ nhật theo kích cỡ là chiều ngang trước chiều dọc sau. Hàm screen.blit giúp chúng ta có thể chèn hình ảnh ta muốn vào ô vuông với tọa độ như trên.

Giờ chúng ta đã vẽ xong bảng và nếu có người chơi thắng hoặc hòa, chúng ta phải in kết quả ra và kết thúc trò chơi. 

  if status == 3:
        font = pygame.font.Font('freesansbold.ttf', 100)
        text = font.render('Draw', True, GREEN, BLUE)
        textRect = text.get_rect()
        textRect.center = (WINDOW_SIZE[0]/2,WINDOW_SIZE[1]/2)
        screen.blit(text,textRect)
        done = True
  if status == 1:
        font = pygame.font.Font('freesansbold.ttf', 100)
        text = font.render('X wins', True, GREEN, BLUE)
        textRect = text.get_rect()
        textRect.center = (WINDOW_SIZE[0]/2,WINDOW_SIZE[1]/2)
        screen.blit(text,textRect)
        done = True
  if status == 2:
        font = pygame.font.Font('freesansbold.ttf', 100)
        text = font.render('O wins', True, GREEN, BLUE)
        textRect = text.get_rect()
        textRect.center = (WINDOW_SIZE[0]/2,WINDOW_SIZE[1]/2)
        screen.blit(text,textRect)
        done = True

Ở đây, các bạn sẽ thấy hàm pygame.font.Font có thể chọn lần lượt font chữ và kích cỡ chữ hiển thị. Ở đây ta sẽ chọn là font freesansbold và file của font đó là freesansbold.ttf,  kích cỡ 100. Nếu status là 3 thì chúng ta có kết quả hòa. Còn nếu status là 2 chúng ta cho người chơi O thắng. Còn là 1 thì người chơi X thắng.

Hàm font.render sẽ giúp chúng ta biểu thị dòng chữ mà mình cần. Còn biến True trong hàm font.render giúp chữ hiển thị nét hơn trên máy tính. GREEN chính là màu của chữ cái ta chọn. BLUE chính là màu phông nền đằng sau. Chúng ta đã tạo các màu này bằng giá trị RGB ở phần đầu chương trình. Hàm get_rect sẽ giúp lấy hình chữ nhật chứa các từ mà các bạn muốn. Sau đó, các bạn hãy nhớ chỉnh tọa độ của hình chữ nhật ở trung tâm là (WINDOW_SIZE[0]/2,WINDOW_SIZE[1]/2). 

Ngoài ra, hàm screen.blit sẽ giúp trò chơi hiển thị chữ cái ta cần ở vị trí hình chữ nhật đó. Và nếu trò chơi kết thúc chúng ta phải đặt biến done là True. 

Sau đó, các bạn sẽ làm trò chơi cập nhật và hiện lên bằng câu lệnh sau:

clock.tick(FPS)
 
# Go ahead and update the screen with what we've drawn.
pygame.display.update()

Hàm clock.tick(FPS) sẽ giúp trò chơi chúng ta mượt hơn và hàm python.display.update() sẽ giúp ta hiện những gì vừa thực hiện lên. FPS là số khung hình trong một giây chúng ta đã tạo ở đầu chương trình.

Kết thúc trò chơi, chúng ta sẽ dừng trò chơi trong 10s để nó giữ kết quả người chơi chiến thắng và thoát khỏi trò chơi.

pygame.time.delay(10000)
quit()
pygame.quit()
sys.exit()

Hàm pygame.time.delay(10000) sẽ giữ trò chơi tầm 10 giây để chúng ta có thể nhìn thấy kết quả trò chơi và sau đó thoát game ra bằng hàm pygame.quit().

4. Tadaa !

Sau trò chơi thú vị này, các bạn học sinh lại được cập nhật thêm những kiến thức thú vị về lập trình python như toán, hàm, câu điều kiện, các vòng lặp…

Đây là một chương trình cần kiến thức khá là khó và dài, nhưng cũng không kém phần thú vị. Các bạn học sinh hãy thử sáng tạo, cải tiến code bằng cách thay hình ảnh của X và O bằng bất cứ hình ảnh nào các bạn thích. Hoặc chúng ta có thể tạo một bảng caro to hơn để chơi đã hơn. 

Sau khi hoàn thành dự án cá nhân, các bạn đừng quên chia sẻ chương trình của mình lên STEAMese Profile để thầy cô và các bạn cùng trải nghiệm nhé!

— — —

STEAM for Vietnam Foundation là tổ chức phi lợi nhuận 501(c)(3) được thành lập tại Hoa Kỳ với sứ mệnh thúc đẩy các hoạt động liên quan tới giáo dục STEAM (Science — Khoa học, Technology — Công nghệ, Engineering — Kỹ thuật, Arts — Nghệ thuật, Mathematics — Toán học) tại Việt nam. STEAM for Vietnam được thành lập và vận hành bởi đội ngũ tình nguyện viên là du học sinh và chuyên gia người Việt trên khắp thế giới.

— — —

📧Email: hello@steamforvietnam.org

🌐Website: www.steamforvietnam.org

🌐Fanpage: STEAM for Vietnam

📺YouTube:  http://bit.ly/S4V_YT

🌐Zalo: Zalo Official

1. Kiến thức lập trình

Chúng ta sẽ áp dụng kiến thức đã được học ở bài 6 của khoá CS 101 để hoàn thành trò chơi này:

• Stack và Queue trong Python. 
• Câu lệnh điều kiện trong Python.
• Vòng lặp while và for trong Python.
• Câu lệnh input() để nhập dữ liệu trong Python.
• Câu lệnh print() để in thông báo ra màn hình.

2. Nội dung trò chơi

Một vật dụng không thể thiếu với các bạn học sinh khi học Toán đó là máy tính cầm tay. Máy tính cầm tay giúp chúng ta tính toán những phép toán cộng, trừ, nhân, chia, và kết hợp với dấu ngoặc đơn. Hẳn bạn học sinh nào cũng biết đến ba câu thần chú quen thuộc khi tính một biểu thức nào đó theo thứ tự tính toán: “Nhân chia trước, cộng trừ sau. Trong ngoặc trước, ngoài ngoặc sau. Tính từ trái sang phải”. Chúng ta có thể sử dụng Python để mô phỏng lại máy tính cầm tay và giúp tính toán nhanh hơn các biểu thức đơn giản với số tự nhiên. Chúng ta có thể chơi thử trò chơi ở đây nhé: https://s4v.trinket.io/sites/calculator  

3. Bắt tay vào lập trình thôi nào!!!

a. Thuật toán

Mỗi biểu thức người chơi nhập vào sẽ có dạng chuỗi (string). Chuỗi có thể xem là một mảng. Chúng ta sẽ lấy lần lượt từng phần tử của mảng. Trong trò chơi, chúng ta sẽ có số tự nhiên và phép toán (cộng, trừ, nhân, chia, ngoặc đơn). Chúng ta sẽ tạo hai mảng. Một mảng để lưu các kết quả tính toán và một mảng để lưu các phép toán.

Vì chúng ta chỉ có thể lấy ra được từng chữ số nên cần tạo một biến để lưu kết quả số có nhiều chữ số. Ví dụ số có một chữ số: 5. Chúng ta thấy 5 = 0 * 10 + 5. Với số có hai chữ số: 35 = (0 * 10 + 3) * 10 + 5. Với số có ba chữ số: 475 = ((0 * 10 + 4) * 10 + 7) * 10 + 5. Như vậy với số, chúng ta có thể lấy các chữ số từ trái sang phải và sử dụng quy luật ở trên. Với mỗi số như vậy, chúng ta sẽ thêm vào mảng chứa kết quả. 

Chúng ta có 4 phép toán: cộng, trừ, nhân, chia, dấu ngoặc đơn. Chúng ta sẽ chia các phép toán thành 3 nhóm: Nhóm 1: cộng và trừ, Nhóm 2: nhân và chia, Nhóm 3: dấu ngoặc đơn. Mỗi nhóm sẽ có một thứ tự ưu tiên, từ lớn đến bé là: Nhóm 2, Nhóm 1, Nhóm 3. 

Khi đi qua các phần tử của chuỗi được nhập vào ban đầu, nếu chúng ta gặp phải phép toán cộng, trừ, nhân, chia, dấu mở ngoặc, chúng ta sẽ kiểm tra thứ tự ưu tiên của nó với phép toán xuất hiện ở trước nó tính từ trái sang phải trong biểu thức. Vì chúng ta phải thực hiện phép toán từ trái sang phải và ưu tiên cho phép toán nhân và chia nên nếu phép toán phía trước có độ ưu tiên lớn hơn hoặc bằng phép toán hiện tại thì chúng ta sẽ thực hiện phép toán phía trước trước. Sau đó, chúng ta sẽ xoá phép toán đó ra khỏi mảng lưu phép toán và thêm vào mảng phép toán hiện tại.

Khi đi qua các phần tử của chuỗi được nhập vào ban đầu, nếu chúng ta gặp phải phép toán mở ngoặc thì chúng ta sẽ thêm nó vào trong mảng phép toán và đợi đến khi gặp phép toán đóng ngoặc. Khi gặp phép toán đóng ngoặc, chúng ta sẽ thực hiện phép toán trong ngoặc và xoá hết các phép toán trong ngoặc và phép toán mở, đóng ngoặc sau khi thực hiện xong.          

Chúng ta có thấy mảng lưu kết quả phép tính và mảng lưu phép toán giống những ngăn xếp (stacks) không nào? Chúng ta đã học ở bài 6 hai câu lệnh với ngăn xếp là push và pop, cùng với câu thần chú LIFO (Last In First Out). Vì chúng ta thực hiện phép toán từ trái sang phải và chúng ta cũng lấy các phép toán theo thứ tự từ trái sang phải nên nó sẽ tuân theo LIFO.

b. Code:

 Bước 1: Viết chương trình chính của trò chơi

Tương tự với blog “Câu chuyện ngẫu nhiên”, chúng ta sẽ sử dụng biến cont và vòng lặp while để tiếp tục hoặc dừng lại trò chơi theo yêu cầu của người chơi. Ngoài ra, chúng ta sẽ sử dụng câu lệnh input() để hỏi người dùng nhập vào biểu thức cần tính. Câu lệnh input() cùng với câu lệnh điều kiện còn giúp hỏi người chơi có muốn tiếp tục trò chơi không. Câu lệnh print() sẽ in ra màn hình kết quả tính toán của hàm evaluate sẽ được viết ở bước 4.

cont = True
while cont:
    formula = input('Nhập biểu thức cần tính với số tự nhiên (gồm các phép tính cộng, trừ, nhân, chia và dấu ngoặc đơn)')
    print('Kết quả của biểu thức là: %s' % str(evaluate(formula)))
    tiep = input('Bạn có muốn tiếp tục không (Y/N)?')
    if tiep.upper() == 'Y':
        cont = True
    else:
        cont = False

Bước 2: Viết hàm kiểm tra phép toán và thứ tự ưu tiên của phép toán:

Chúng ta sẽ viết hàm is_op để kiểm tra xem input có phải là một trong những phép toán cộng, trừ, nhân, chia hay không. Chúng ta sẽ sử dụng câu lệnh in. Câu lệnh trả về True hoặc False.

def is_op(c):
    return c in ['+', '-', '*', '/']

Tiếp theo, chúng ta sẽ viết hàm priority để trả về thứ tự ưu tiên của phép toán. Phép toán nhân chia sẽ được thực hiện trước, nên có thứ tự ưu tiên là 2. Phép toán cộng trừ có thứ tự ưu tiên 1. Phép toán mở ngoặc có thứ tự ưu tiên là -1. Những phép toán nào có thứ tự ưu tiên cao hơn sẽ được thực hiện trước.       

def priority(op):
    if op == '+' or op == '-':
        return 1
    if op == '*' or op == '/':
        return 2
    return -1

Bước 3: Viết hàm thực hiện phép toán:

Chúng ta sẽ viết hàm process_op nhận vào ngăn xếp lưu kết quả phép toán và phép toán. Hàm thêm kết quả phép toán mới vào ngăn xếp và trả về ngăn xếp. Với mỗi phép toán mới, chúng ta sẽ lấy ra kết quả trước và sau phép toán đó từ ngăn xếp bằng câu lệnh .pop(). Sau đó hàm sẽ thực hiện phép toán và thêm kết quả vào ngăn xếp. 

Trường hợp đặc biệt: Số chia bằng 0 trong phép chia thì chúng ta sẽ thêm vào ngăn xếp kết quả vô cùng (∞). Trong Python sẽ là float(“inf”). Chúng ta sẽ sử dụng ký tự đặc biệt này để dừng vòng lặp ở hàm chính được viết ở bước 4.

def process_op(st, op):
  r = st.pop()
  l = st.pop()
  if op == '+':
      st.append(l + r)
  elif op == '-':
      st.append(l - r)
  elif op == '*':
      st.append(l * r)
  elif op == '/':
      if r == 0:
          print('Biểu thức có phép chia cho 0: ' + str(l) + '/' + str(r))
          st.append(float("inf"))
      else:
          st.append(l / r)
  return st      

Bước 4: Viết hàm evaluate:

Hàm evaluate nhận vào chuỗi s và in ra kết quả tính toán cuối cùng. Chúng ta sẽ tạo 2 ngăn xếp bằng mảng. Ngăn xếp st để lưu các kết quả tính toán và ngăn xếp op để lưu các phép toán. Chúng ta sẽ sử dụng vòng lặp for cùng với hàm range và len để đi qua các phần tử của chuỗi. range(len(s)) dùng để tạo một mảng gồm các số tự nhiên bắt đầu từ 0 với các phần tử nhỏ hơn chiều dài của mảng s. Các phần tử này tương ứng với index của các phần tử của chuỗi s.

Trường hợp thứ nhất khi phần tử trong chuỗi là khoảng trắng thì chúng ta sẽ không làm gì, và tiếp tục đi đến phần tử khác của chuỗi bằng câu lệnh continue. Trường hợp thứ hai khi phần tử trong chuỗi là dấu mở ngoặc, chúng ta sẽ thêm phép toán mở ngoặc vào ngăn xếp op. Trường hợp thứ ba khi phần tử trong chuỗi là một chữ số, chúng ta sẽ tìm tiếp từ phần tử đó đến hết chuỗi xem có chữ số nào nối tiếp không để tạo thành một số có nhiều chữ số. Để tìm xem phần tử có phải là số không, chúng ta có thể sử dụng câu lệnh isnumeric(). Để lấy ra các phần tử tiếp theo chúng ta có thể sử dụng vòng lặp for cùng với hàm range. range(i, len(s)) dùng để tạo một mảng gồm các số tự nhiên bắt đầu từ i với các phần tử nhỏ hơn chiều dài của mảng s. Để dừng lại khi không còn gặp các chữ số liên tiếp trong chuỗi, chúng ta dùng câu lệnh break.  

Chúng ta sẽ tính ra giá trị của số có nhiều chữ số bằng công thức ở phần Thuật toán. Khi tính ra số, chúng ta sẽ thêm số đó vào ngăn xếp st (push) bằng câu lệnh .append(). Vì vòng lặp khi đi qua từng phần tử của chuỗi sẽ tăng index lên 1 đơn vị, nên để tránh bị lỗi khi có nhiều chữ số liền nhau, tạo thành một số có nhiều chữ số, chúng ta sẽ sử dụng một mảng có kích thước bằng với kích thước của chuỗi. Mảng này sẽ có kiểu dữ liệu boolean và được khởi tạo bằng False với tất cả các phần tử của mảng. Các phần tử của mảng này sẽ được gán là True nếu nó tương ứng với các chữ số đã đi qua trong chuỗi s. Như vậy chúng ta chỉ xét những vị trí có giá trị False.

st = []
op = []
mst = [False] * len(s)
for i in range(len(s)):
  if s[i] == ' ':
      continue
  elif s[i] == '(':
      op.append('(')
  elif not mst[i]:
      num = 0
      for j in range(i, len(s)):
          if s[j].isnumeric():
              num = num * 10 + int(s[j])
              mst[j] = True
          else:
              break
      st.append(num)

Trường hợp thứ tư khi phần tử trong chuỗi là một trong các phép toán cộng, trừ, nhân, chia. Chúng ta có thể kiểm tra việc này bằng hàm is_op. Chúng ta sẽ so sánh thứ tự ưu tiên của phép toán đó với thứ tự ưu tiên của phép toán trước đó. Nếu phép toán trước đó có thứ tự ưu tiên lớn hơn hoặc bằng thứ tự ưu tiên của phép toán hiện tại thì chúng ta sẽ thực hiện phép toán trước đó bằng hàm process_op và bỏ phép toán trước đó ra khỏi mảng op bằng câu lệnh .pop() với ngăn xếp cho đến khi ngăn xếp op không còn phần tử nào. Hàm process_op nhận vào 2 inputs là mảng st để lưu kết quả của phép tính và phép toán trước đó. Chúng ta có thể dùng vòng lặp while để làm việc này. Cuối cùng chúng ta sẽ thêm phép toán hiện tại vào mảng op (push) bằng câu lệnh .append().  

elif is_op(s[i]):
    cur_op = s[i]
    while len(op) != 0 and priority(op[-1]) >= priority(cur_op):
        st = process_op(st, op[-1])
        op.pop()
    op.append(cur_op)

Trường hợp thứ năm khi phần tử trong chuỗi là dấu đóng ngoặc thì chúng ta sẽ thực hiện các phép toán trước đó bằng hàm process_op cho đến khi gặp dấu mở ngoặc trong ngăn xếp op. Sau khi thực hiện mỗi phép toán, chúng ta phải bỏ phép toán vừa thực hiện ra khỏi ngăn xếp op bằng câu lệnh .pop(). Và cuối cùng là phải bỏ dấu mở ngoặc tương ứng ra khỏi ngăn xếp op.

elif s[i] == ')':
    while op[-1] != '(':
        st = process_op(st, op[-1])
        op.pop()
    op.pop()

Chúng ta sẽ dừng vòng lặp đi qua các phần tử của s nếu trong ngăn xếp st có kết quả vô cùng (khi chia cho 0). Cuối cùng sau khi đi hết các phần tử của chuỗi s, chúng ta sẽ phải thực hiện các phép toán còn lại trong ngăn xếp op và bỏ phép toán vừa thực hiện ra khỏi ngăn xếp cho đến khi hết phần tử trong ngăn xếp.

while op:
    st = process_op(st, op[-1])
    op.pop()

Code hoàn chỉnh của hàm evaluate là

def evaluate(s):
    st = []
    op = []
    mst = [False] * len(s)
    for i in range(len(s)):
        if s[i] == ' ':
            continue
        elif s[i] == '(':
            op.append('(')
        elif s[i] == ')':
            while op[-1] != '(':
                st = process_op(st, op[-1])
                op.pop()
            op.pop()
        elif is_op(s[i]):
            cur_op = s[i]
            while len(op) != 0 and priority(op[-1]) >= priority(cur_op):
                st = process_op(st, op[-1])
                op.pop()
            op.append(cur_op)
        elif not mst[i]:
            num = 0
            for j in range(i, len(s)):
                if s[j].isnumeric():
                    num = num * 10 + int(s[j])
                    mst[j] = True
                else:
                    break
            st.append(num)
        if float("inf") in st:
            break
    while op:
        st = process_op(st, op[-1])
        if float("inf") in st:
            break
        op.pop()
    return st[0]

4. Tada!!! 

Như vậy chúng ta đã hoàn thành trò chơi rồi đấy. Thật đơn giản đúng không nào. Chúng ta cần thêm một điều kiện nếu kết quả từ hàm evaluate khác vô cùng thì sẽ in kết quả ra màn hình.

Code hoàn chỉnh sẽ là:

# -*- coding: utf-8 -*-

def is_op(c):
    return c in ['+', '-', '*', '/']


def priority(op):
    if op == '+' or op == '-':
        return 1
    if op == '*' or op == '/':
        return 2
    return -1


def process_op(st, op):
    r = st.pop()
    l = st.pop()
    if op == '+':
        st.append(l + r)
    elif op == '-':
        st.append(l - r)
    elif op == '*':
        st.append(l * r)
    elif op == '/':
        if r == 0:
            print('Biểu thức có phép chia cho 0: ' + str(l) + '/' + str(r))
            st.append(float("inf"))
        else:
            st.append(l / r)
    return st


def evaluate(s):
    st = []
    op = []
    mst = [False] * len(s)
    for i in range(len(s)):
        if s[i] == ' ':
            continue
        elif s[i] == '(':
            op.append('(')
        elif s[i] == ')':
            while op[-1] != '(':
                st = process_op(st, op[-1])
                op.pop()
            op.pop()
        elif is_op(s[i]):
            cur_op = s[i]
            while len(op) != 0 and priority(op[-1]) >= priority(cur_op):
                st = process_op(st, op[-1])
                op.pop()
            op.append(cur_op)
        elif not mst[i]:
            num = 0
            for j in range(i, len(s)):
                if s[j].isnumeric():
                    num = num * 10 + int(s[j])
                    mst[j] = True
                else:
                    break
            st.append(num)
        if float("inf") in st:
            break
    while op:
        st = process_op(st, op[-1])
        if float("inf") in st:
            break
        op.pop()
    return st[0]
    
cont = True
while cont:
    formula = input('Nhập biểu thức cần tính với số tự nhiên (gồm các phép tính cộng, trừ, nhân, chia và dấu ngoặc đơn)')
    result = evaluate(formula)
    if result != float("inf"):
        print('Kết quả của biểu thức là: %s' % str(evaluate(formula)))
    tiep = input('Bạn có muốn tiếp tục không (Y/N)?')
    if tiep.upper() == 'Y':
        cont = True
    else:
        cont = False

Chương trình của chúng ta mới chỉ thực hiện các phép toán đơn giản với số tự nhiên. Các bạn học sinh hãy thử sáng tạo, cải tiến code để có thể thực hiện các phép toán với cả số thập phân và luỹ thừa, căn bậc hai nhé! Sau khi hoàn thành dự án cá nhân, các bạn đừng quên chia sẻ chương trình của mình lên STEAMese Profile để thầy cô và các bạn cùng trải nghiệm. 

— — —

STEAM for Vietnam Foundation là tổ chức phi lợi nhuận 501(c)(3) được thành lập tại Hoa Kỳ với sứ mệnh thúc đẩy các hoạt động liên quan tới giáo dục STEAM (Science — Khoa học, Technology — Công nghệ, Engineering — Kỹ thuật, Arts — Nghệ thuật, Mathematics — Toán học) tại Việt nam. STEAM for Vietnam được thành lập và vận hành bởi đội ngũ tình nguyện viên là du học sinh và chuyên gia người Việt trên khắp thế giới.

— — —

📧Email: hello@steamforvietnam.org

🌐Website: www.steamforvietnam.org

🌐Fanpage: STEAM for Vietnam

📺YouTube:  http://bit.ly/S4V_YT

🌐Zalo: Zalo Official