課程：《Python程式設計》
班級： 2133
姓名： 陳瑾凱
學號： 20213328　　　　　
實驗教師：王志強
實驗日期：2022年5月28日必修/選修： 公選課

一.實驗內容

   （Python綜合應用：爬蟲、資料處理、視覺化、機器學習、神經網路、遊戲、網路安全等。）

     通過python程式製作一個小遊戲——俄羅斯方塊，並在華為雲ESC上執行。

二. 實驗過程及結果

2.1.程式碼如下：

import tkinter as tk  # 匯入包，並取名為tk
from tkinter import messagebox  # 呼叫tkinter庫裡面的messagebox
import random  #
 
 匯入隨機庫

R = 20  # 行數
C = 12  # 列數
cell_size = 30  # 定義一個小方格的長度
height = R * cell_size  # 高度
width = C * cell_size  # 寬度
FPS = 300  # 設定頁面重新整理的間隔

# 建立字典，存放俄羅斯方塊形狀的對應座標
SHAPES = {
    "Z": [(-1, -1), (0, -1), (0, 0), (1, 0)],
    "O": [(-1, -1), (0, -1), (-1, 0), (0, 0)],
    "S": [(-1, 0), (0, 0), (0, -1), (1, -1)],
    
 
"T": [(-1, 0), (0, 0), (0, -1), (1, 0)],
    "I": [(0, 1), (0, 0), (0, -1), (0, -2)],
    "L": [(-1, 0), (0, 0), (-1, -1), (-1, -2)],
    "J": [(-1, 0), (0, 0), (0, -1), (0, -2)]
}

# 建立字典，存放不同俄羅斯方塊對應的不同顏色
SHAPESCOLOR = {
    "O": "blue",
    "Z": "Cyan",
    "S": "red",
    "T": "yellow",
    "I": "green",
    "L": "
 
purple",
    "J": "orange",
}


def draw_cell_by_cr(canvas, c, r, color="#CCCCCC"):  # 在畫板上繪製單個俄羅斯方塊的函式
    # 確定座標
    x0 = c * cell_size
    y0 = r * cell_size
    x1 = x0 + cell_size
    y1 = y0 + cell_size
    canvas.create_rectangle(x0, y0, x1, y1, fill=color, outline="white", width=2)  # 在指定位置繪製矩形，填充顏色，並且設定邊框的寬度、顏色


def draw_board(canvas, block_list):  # 在畫板上繪製所有空白方塊的函式
    for ri in range(R):  # 遍所有歷行
        for ci in range(C):  # 遍歷每一行中的每一列
            cell_type = block_list[ri][ci]  # 取出當前位置對應的值
            if cell_type:  # 如果有俄羅斯方塊，按俄羅斯方塊顏色繪製
                draw_cell_by_cr(canvas, ci, ri, SHAPESCOLOR[cell_type])
            else:  # 如果無俄羅斯方塊，則按預設顏色繪製
                draw_cell_by_cr(canvas, ci, ri)  # 所有閒置方格均設定預設顏色為背景


def draw_cells(canvas, c, r, cell_list, color="#CCCCCC"):  # 繪製指定形狀和顏色的俄羅斯方塊的函式
    for i in cell_list:  # 計算每個方塊的實際座標
        cell_c, cell_r = i
        ci = cell_c + c
        ri = cell_r + r
        if 0 <= c < C and 0 <= r < R:  # 判斷該方塊位置是否在畫板內
            draw_cell_by_cr(canvas, ci, ri, color)


win = tk.Tk()  # 建立一個新視窗
canvas = tk.Canvas(win, width=width, height=height)  # 繪製畫布
canvas.pack()  # 放置畫布
block_list = []  # 建立列表，用來記錄已固定的俄羅斯方塊
for i in range(R):  # 製作一個R行C列的二維列表
    i_row = ['' for j in range(C)]
    block_list.append(i_row)

draw_board(canvas, block_list)


def draw_block_move(canvas, block, direction=[0, 0]):  # 繪製指定方向移動後的俄羅斯方塊的函式
    shape_type = block['kind']
    c, r = block['cr']
    cell_list = block['cell_list']

    # 移動前，先清除原有位置繪製的俄羅斯方塊,也就是用背景色繪製原有的俄羅斯方塊
    draw_cells(canvas, c, r, cell_list)
    dc, dr = direction
    new_c, new_r = c + dc, r + dr
    block['cr'] = [new_c, new_r]

    # 在新位置繪製新的俄羅斯方塊
    draw_cells(canvas, new_c, new_r, cell_list, SHAPESCOLOR[shape_type])


def generate_new_block():  # 隨機生成新的俄羅斯方塊的函式
    kind = random.choice(list(SHAPES.keys()))  # 隨機選擇俄羅斯方塊型別
    cr = [C // 2, 0]
    new_block = {
        "kind": kind,
        "cell_list": SHAPES[kind],
        "cr": cr
    }
    return new_block  # 返回新生成的俄羅斯方塊物件


def check_move(block, direction=[0, 0]):  # 判斷俄羅斯方塊是否可以向指定位置移動的函式
    cc, cr = block['cr']  # 當前俄羅斯方塊物件的位置
    cell_list = block['cell_list']  # 相對自身的位置列表
    for cell in cell_list:
        cell_c, cell_r = cell
        c = cell_c + cc + direction[0]
        r = cell_r + cr + direction[1]
        if c < 0 or c >= C or r >= R:  # 判斷俄羅斯方塊移動後是是否會越界
            return False  # 返回值為假
        if r >= 0 and block_list[r][c]:
            return False  # 返回值為假
    return True  # 返回值為真


def save_block_to_list(block):  # 將無法移動的俄羅斯方塊記錄下來的函式
    shape_type = block['kind']
    cc, cr = block['cr']
    cell_list = block['cell_list']

    for cell in cell_list:
        cell_c, cell_r = cell
        c = cell_c + cc
        r = cell_r + cr
        block_list[r][c] = shape_type


def horizontal_move_block(event):  # 控制俄羅斯方塊左右移動的函式
    direction = [0, 0]
    # 接收判斷鍵盤輸入的命令
    if event.keysym == 'Left':  # 是否向左
        direction = [-1, 0]
    elif event.keysym == 'Right':  # 是否向右
        direction = [1, 0]
    else:  # 無指令
        return

    global current_block  # 獲取當前的俄羅斯方塊物件
    if current_block is not None and check_move(current_block, direction):  # 判斷是否為空且能否移動
        draw_block_move(canvas, current_block, direction)  # 移動繪製這個俄羅斯方塊


def rotate_block(event):  # 讓俄羅斯方塊旋轉的函式
    global current_block  # 獲取當前俄羅斯方塊
    if current_block is None:  # 判斷是否為空
        return
    cell_list = current_block['cell_list']
    rotate_list = []
    for cell in cell_list:  # 對該俄羅斯方塊的所有方格進行旋轉變換
        cell_c, cell_r = cell
        rotate_cell = [cell_r, -cell_c]
        rotate_list.append(rotate_cell)

    # 生成一個旋轉後的俄羅斯方塊物件
    block_after_rotate = {
        'kind': current_block['kind'],  # 對應俄羅斯方塊的型別
        'cell_list': rotate_list,
        'cr': current_block['cr']
    }

    if check_move(block_after_rotate):  # 判斷旋轉後的俄羅斯方塊能否移動
        cc, cr = current_block['cr']
        draw_cells(canvas, cc, cr, current_block['cell_list'])  # 清楚舊的俄羅斯方塊
        draw_cells(canvas, cc, cr, rotate_list, SHAPESCOLOR[current_block['kind']])  # 繪製新的俄羅斯方塊
        current_block = block_after_rotate  # 更改變數


def check_row_complete(row):
    for cell in row:
        if cell == '':
            return False
    return True


score = 0  # 給成績變數賦初值
win.title("SCORES: %s" % score)  # 在標題上顯示分數


def check_and_clear():  # 檢查並且清楚排滿的行的函式
    has_complete_row = False
    for ri in range(len(block_list)):
        if check_row_complete(block_list[ri]):  # 判斷有沒有可以刪除的行
            has_complete_row = True
            if ri > 0:  # 判斷是否為第一行
                for cur_ri in range(ri, 0, -1):  # 從下往上遍歷，讓當前行等於上一行
                    block_list[cur_ri] = block_list[cur_ri - 1][:]
                block_list[0] = ['' for j in range(C)]
            else:  # 如果為第一行，建立一個空行
                block_list[ri] = ['' for j in range(C)]
            global score  # 讀取分數
            score += 10  # 加分
    if has_complete_row:  # 判斷是否有清楚的行，有的話加分
        draw_board(canvas, block_list)
        win.title("SCORES: %s" % score)


def land(event):  # 讓俄羅斯方塊立即著陸的函式
    global current_block  # 獲取當前俄羅斯方塊
    if current_block is None:  # 判斷是否為空
        return
    cell_list = current_block['cell_list']
    cc, cr = current_block['cr']
    min_height = R
    for cell in cell_list:
        cell_c, cell_r = cell
        c, r = cell_c + cc, cell_r + cr
        if block_list[r][c]:  # 判斷是否衝突
            return
        h = 0
        for ri in range(r + 1, R):  # 遍歷該指令的方格
            if block_list[ri][c]:  # 判斷下面是否有固定的物體
                break  # 如果有，跳出迴圈
            else:  # 如果沒有
                h = h + 1  # 行數加一
        if h < min_height:  # 判斷大小
            min_height = h  # 更新最小值
    down = [0, min_height]
    if check_move(current_block, down):  # 判斷是否能移動
        draw_block_move(canvas, current_block, down)


def game_loop():
    win.update()
    global current_block  # 引入全域性變數
    if current_block is None:  # 判斷是否存在
        new_block = generate_new_block()  # 新生成一個俄羅斯方塊
        draw_block_move(canvas, new_block)  # 移動俄羅斯方塊
        current_block = new_block  # 當前俄羅斯方塊物件為新生成的俄羅斯方塊
        if not check_move(current_block, [0, 0]):  # 判斷能否繼續向下生成俄羅斯方塊
            messagebox.showinfo("Game Over!", "Your Score is %s" % score)  # 跳出彈窗，遊戲結束
            win.destroy()
            return
    else:
        if check_move(current_block, [0, 1]):  # 判斷能否繼續向下移動
            draw_block_move(canvas, current_block, [0, 1])  # 直接向下移動俄羅斯方塊
        else:
            save_block_to_list(current_block)  # 將不能移動的俄羅斯方塊存入列表
            current_block = None
    check_and_clear()
    win.after(FPS, game_loop)


canvas.focus_set()  # 聚焦到canvas畫板物件上
# 繫結方向鍵
canvas.bind("<KeyPress-Left>", horizontal_move_block)
canvas.bind("<KeyPress-Right>", horizontal_move_block)
canvas.bind("<KeyPress-Up>", rotate_block)
canvas.bind("<KeyPress-Down>", land)

current_block = None  # 定義初始值為none
game_loop()  # 呼叫函式，定時重新整理頁面
win.mainloop()  # 維持視窗

2.2實驗時的具體過程
1.定義各引數，建立字典並存放代表俄羅斯方塊形狀的對應座標，不同俄羅斯方塊對應的不同顏色。

import tkinter as tk  # 匯入包，並取名為tk
from tkinter import messagebox  # 呼叫tkinter庫裡面的messagebox
import random  # 匯入隨機庫

R = 20  # 行數
C = 12  # 列數
cell_size = 30  # 定義一個小方格的長度
height = R * cell_size  # 高度
width = C * cell_size  # 寬度
FPS = 300  # 設定頁面重新整理的間隔

# 建立字典，存放俄羅斯方塊形狀的對應座標
SHAPES = {
    "Z": [(-1, -1), (0, -1), (0, 0), (1, 0)],
    "O": [(-1, -1), (0, -1), (-1, 0), (0, 0)],
    "S": [(-1, 0), (0, 0), (0, -1), (1, -1)],
    "T": [(-1, 0), (0, 0), (0, -1), (1, 0)],
    "I": [(0, 1), (0, 0), (0, -1), (0, -2)],
    "L": [(-1, 0), (0, 0), (-1, -1), (-1, -2)],
    "J": [(-1, 0), (0, 0), (0, -1), (0, -2)]
}

# 建立字典，存放不同俄羅斯方塊對應的不同顏色
SHAPESCOLOR = {
    "O": "blue",
    "Z": "Cyan",
    "S": "red",
    "T": "yellow",
    "I": "green",
    "L": "purple",
    "J": "orange",
}

2.在畫板上繪製俄羅斯方塊的函式，填充顏色，設定邊框寬度與顏色，繪製空白方塊函式，繪製指定形狀和顏色的俄羅斯方塊函式，並通過判斷驗證方塊位置。

def draw_cell_by_cr(canvas, c, r, color="#CCCCCC"):  # 在畫板上繪製單個俄羅斯方塊的函式
    # 確定座標
    x0 = c * cell_size
    y0 = r * cell_size
    x1 = x0 + cell_size
    y1 = y0 + cell_size
    canvas.create_rectangle(x0, y0, x1, y1, fill=color, outline="white", width=2)  # 在指定位置繪製矩形，填充顏色，並且設定邊框的寬度、顏色


def draw_board(canvas, block_list):  # 在畫板上繪製所有空白方塊的函式
    for ri in range(R):  # 遍所有歷行
        for ci in range(C):  # 遍歷每一行中的每一列
            cell_type = block_list[ri][ci]  # 取出當前位置對應的值
            if cell_type:  # 如果有俄羅斯方塊，按俄羅斯方塊顏色繪製
                draw_cell_by_cr(canvas, ci, ri, SHAPESCOLOR[cell_type])
            else:  # 如果無俄羅斯方塊，則按預設顏色繪製
                draw_cell_by_cr(canvas, ci, ri)  # 所有閒置方格均設定預設顏色為背景


def draw_cells(canvas, c, r, cell_list, color="#CCCCCC"):  # 繪製指定形狀和顏色的俄羅斯方塊的函式
    for i in cell_list:  # 計算每個方塊的實際座標
        cell_c, cell_r = i
        ci = cell_c + c
        ri = cell_r + r
        if 0 <= c < C and 0 <= r < R:  # 判斷該方塊位置是否在畫板內
            draw_cell_by_cr(canvas, ci, ri, color)


win = tk.Tk()  # 建立一個新視窗
canvas = tk.Canvas(win, width=width, height=height)  # 繪製畫布
canvas.pack()  # 放置畫布
block_list = []  # 建立列表，用來記錄已固定的俄羅斯方塊
for i in range(R):  # 製作一個R行C列的二維列表
    i_row = ['' for j in range(C)]
    block_list.append(i_row)

draw_board(canvas, block_list)


def draw_block_move(canvas, block, direction=[0, 0]):  # 繪製指定方向移動後的俄羅斯方塊的函式
    shape_type = block['kind']
    c, r = block['cr']
    cell_list = block['cell_list']

    # 移動前，先清除原有位置繪製的俄羅斯方塊,也就是用背景色繪製原有的俄羅斯方塊
    draw_cells(canvas, c, r, cell_list)
    dc, dr = direction
    new_c, new_r = c + dc, r + dr
    block['cr'] = [new_c, new_r]

    # 在新位置繪製新的俄羅斯方塊
    draw_cells(canvas, new_c, new_r, cell_list, SHAPESCOLOR[shape_type])

3.設定俄羅斯方塊函式——生成新的俄羅斯方塊，俄羅斯方塊朝指定位置移動，俄羅斯方塊是否越界，將無法移動的俄羅斯方塊記錄下來的函式。

def generate_new_block():  # 隨機生成新的俄羅斯方塊的函式
    kind = random.choice(list(SHAPES.keys()))  # 隨機選擇俄羅斯方塊型別
    cr = [C // 2, 0]
    new_block = {
        "kind": kind,
        "cell_list": SHAPES[kind],
        "cr": cr
    }
    return new_block  # 返回新生成的俄羅斯方塊物件


def check_move(block, direction=[0, 0]):  # 判斷俄羅斯方塊是否可以向指定位置移動的函式
    cc, cr = block['cr']  # 當前俄羅斯方塊物件的位置
    cell_list = block['cell_list']  # 相對自身的位置列表
    for cell in cell_list:
        cell_c, cell_r = cell
        c = cell_c + cc + direction[0]
        r = cell_r + cr + direction[1]
        if c < 0 or c >= C or r >= R:  # 判斷俄羅斯方塊移動後是是否會越界
            return False  # 返回值為假
        if r >= 0 and block_list[r][c]:
            return False  # 返回值為假
    return True  # 返回值為真


def save_block_to_list(block):  # 將無法移動的俄羅斯方塊記錄下來的函式
    shape_type = block['kind']
    cc, cr = block['cr']
    cell_list = block['cell_list']

    for cell in cell_list:
        cell_c, cell_r = cell
        c = cell_c + cc
        r = cell_r + cr
        block_list[r][c] = shape_type

4.控制俄羅斯方塊左右移動的函式，讓俄羅斯方塊旋轉的函式等

def horizontal_move_block(event):  # 控制俄羅斯方塊左右移動的函式
    direction = [0, 0]
    # 接收判斷鍵盤輸入的命令
    if event.keysym == 'Left':  # 是否向左
        direction = [-1, 0]
    elif event.keysym == 'Right':  # 是否向右
        direction = [1, 0]
    else:  # 無指令
        return

    global current_block  # 獲取當前的俄羅斯方塊物件
    if current_block is not None and check_move(current_block, direction):  # 判斷是否為空且能否移動
        draw_block_move(canvas, current_block, direction)  # 移動繪製這個俄羅斯方塊


def rotate_block(event):  # 讓俄羅斯方塊旋轉的函式
    global current_block  # 獲取當前俄羅斯方塊
    if current_block is None:  # 判斷是否為空
        return
    cell_list = current_block['cell_list']
    rotate_list = []
    for cell in cell_list:  # 對該俄羅斯方塊的所有方格進行旋轉變換
        cell_c, cell_r = cell
        rotate_cell = [cell_r, -cell_c]
        rotate_list.append(rotate_cell)

    # 生成一個旋轉後的俄羅斯方塊物件
    block_after_rotate = {
        'kind': current_block['kind'],  # 對應俄羅斯方塊的型別
        'cell_list': rotate_list,
        'cr': current_block['cr']
    }

    if check_move(block_after_rotate):  # 判斷旋轉後的俄羅斯方塊能否移動
        cc, cr = current_block['cr']
        draw_cells(canvas, cc, cr, current_block['cell_list'])  # 清楚舊的俄羅斯方塊
        draw_cells(canvas, cc, cr, rotate_list, SHAPESCOLOR[current_block['kind']])  # 繪製新的俄羅斯方塊
        current_block = block_after_rotate  # 更改變數


def check_row_complete(row):
    for cell in row:
        if cell == '':
            return False
    return True


score = 0  # 給成績變數賦初值
win.title("SCORES: %s" % score)  # 在標題上顯示分數


def check_and_clear():  # 檢查並且清楚排滿的行的函式
    has_complete_row = False
    for ri in range(len(block_list)):
        if check_row_complete(block_list[ri]):  # 判斷有沒有可以刪除的行
            has_complete_row = True
            if ri > 0:  # 判斷是否為第一行
                for cur_ri in range(ri, 0, -1):  # 從下往上遍歷，讓當前行等於上一行
                    block_list[cur_ri] = block_list[cur_ri - 1][:]
                block_list[0] = ['' for j in range(C)]
            else:  # 如果為第一行，建立一個空行
                block_list[ri] = ['' for j in range(C)]
            global score  # 讀取分數
            score += 10  # 加分
    if has_complete_row:  # 判斷是否有清楚的行，有的話加分
        draw_board(canvas, block_list)
        win.title("SCORES: %s" % score)


def land(event):  # 讓俄羅斯方塊立即著陸的函式
    global current_block  # 獲取當前俄羅斯方塊
    if current_block is None:  # 判斷是否為空
        return
    cell_list = current_block['cell_list']
    cc, cr = current_block['cr']
    min_height = R
    for cell in cell_list:
        cell_c, cell_r = cell
        c, r = cell_c + cc, cell_r + cr
        if block_list[r][c]:  # 判斷是否衝突
            return
        h = 0
        for ri in range(r + 1, R):  # 遍歷該指令的方格
            if block_list[ri][c]:  # 判斷下面是否有固定的物體
                break  # 如果有，跳出迴圈
            else:  # 如果沒有
                h = h + 1  # 行數加一
        if h < min_height:  # 判斷大小
            min_height = h  # 更新最小值
    down = [0, min_height]
    if check_move(current_block, down):  # 判斷是否能移動
        draw_block_move(canvas, current_block, down)


def game_loop():
    win.update()
    global current_block  # 引入全域性變數
    if current_block is None:  # 判斷是否存在
        new_block = generate_new_block()  # 新生成一個俄羅斯方塊
        draw_block_move(canvas, new_block)  # 移動俄羅斯方塊
        current_block = new_block  # 當前俄羅斯方塊物件為新生成的俄羅斯方塊
        if not check_move(current_block, [0, 0]):  # 判斷能否繼續向下生成俄羅斯方塊
            messagebox.showinfo("Game Over!", "Your Score is %s" % score)  # 跳出彈窗，遊戲結束
            win.destroy()
            return
    else:
        if check_move(current_block, [0, 1]):  # 判斷能否繼續向下移動
            draw_block_move(canvas, current_block, [0, 1])  # 直接向下移動俄羅斯方塊
        else:
            save_block_to_list(current_block)  # 將不能移動的俄羅斯方塊存入列表
            current_block = None
    check_and_clear()
    win.after(FPS, game_loop)


canvas.focus_set()  # 聚焦到canvas畫板物件上
# 繫結方向鍵
canvas.bind("<KeyPress-Left>", horizontal_move_block)
canvas.bind("<KeyPress-Right>", horizontal_move_block)
canvas.bind("<KeyPress-Up>", rotate_block)
canvas.bind("<KeyPress-Down>", land)

current_block = None  # 定義初始值為none
game_loop()  # 呼叫函式，定時重新整理頁面
win.mainloop()  # 維持視窗

 2.3.實驗結果

 華為雲ESC上執行結果

這裡不知道為啥無法執行，就只能把在虛擬機器上無法執行的圖片發上來了

三.實驗總結：

1.這次的實驗讓我明白很多程式碼雖然長但並不複雜，有很多重複的地方都可以借鑑。
2.在程式碼冗長時一定要記得撰寫備註，這是一個好習慣，因為寫註釋不會消耗很多時間，卻會讓你能更好的糾錯和分析程式碼

感想
這是python課的最後一次實驗了，回憶起這長達四個月的學習時光，從最初的實驗一熟悉python開發環境開始一直到如今的結課作業，
我們在有限的課時裡學習了很多知識，變數賦值、運算子及其優先順序、基本資料型別、迴圈語句、列表、元組、字典、集合、字串與
正則表達、Python操作資料庫、Python爬蟲等等，在總結之前我都沒有想到短短四個月能有這麼多內容從我面前閃過，我開始懷疑我
上課的專注度和對知識的接受是否全面，但現在想來這一切都為時已晚，無論我是否從這節課學到本領，它都已經成為了過去，想起來
第一次上課的時候我連python書都沒有就覺得好笑，我不覺得我是一個認真的學生，這次的結課作業也碰到了許許多多的難題，但也最
終被跌跌絆絆的克服了。在我看來，能遇上一位好老師是我的幸運，第一次見到老師還以為您和我們一樣是學生，當時我就覺得這個老師
上課一定很生動，老師您也沒有辜負我們的期待，用有趣而生動的語言解決了每一個問題，講述了每一個知識點，就是每節課講的都好多
根本記不過來，最後也可以希望觸類旁通，帶著老師教給我們的學習python的方法，去學習其他各種語言，這算是也是收穫的一種吧。