2025年3月27日星期四

green judge problems

https://web.archive.org/web/20210917163453/http://www.tcgs.tc.edu.tw:1218/Problems

2025年3月11日星期二

組字程式 III

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

import tkinter as tk

from tkinter import ttk

import pyttsx3

import random

# 初始化語音引擎

engine = pyttsx3.init()

# 字首、字根、字尾選項

prefixes = sorted("ante,anti,auto,ambi,apo,be,bene,bi,circ,co,com,col,con,contra,counter,de,dia,dis,en,ex,extra,hetero,homo,hyper,il,im,in,inter,intra,intro,ir,mal,mega,micro,mis,mono,multi,neo,non,ob,para,pan,per,poly,post,pre,pro,re,se,semi,sub,super,supra,sur,sym,syn,tele,trans,tri,uni".split(','))

roots = sorted("ann,audi,bio,cap,ceive,cip,cept,ced,ceed,cess,cede,circ,cyc,dem,demo,dict,divid,duc,equ,flect,flex,form,gram,graph,gress,ject,manu,mob,mot,mov,nov,ped,pict,port,pos,press,rupt,scribe,serve,sist,spec,spir,tain,tract,vid,vise,viv,volv,astro,bell,cardi,chron,corp,cred,geo,hydr,luc,phon,therm".split(','))

suffixes = sorted("er,or,an,ian,ant,ent,ar,ate,ee,eer,ese,ess,ic,ics,ician,ist,ster,al,age,ance,ence,ancy,ency,dom,hood,ism,ity,ty,logy,ment,ness,ory,ship,tion,ation,sion,ure,ture,ate,en,fy,ify,ish,ize,ise,le,able,ible,ary,ful,ical,id,ior,ive,less,like,ly,ous,proof,ward,wards,way,ways,wise,acious,tude,phobia,escence,ory,cule,ling".split(','))

# 建立主視窗

root = tk.Tk()

root.title("字根組合器")

root.geometry("550x450")

# 設定標籤

tk.Label(root, text="選擇字首:").grid(row=0, column=0, padx=10, pady=10)

tk.Label(root, text="選擇字根:").grid(row=0, column=1, padx=10, pady=10)

tk.Label(root, text="選擇字尾:").grid(row=0, column=2, padx=10, pady=10)

tk.Label(root, text="組合的單字:").grid(row=4, column=0, padx=10, pady=10)

# 建立 Combobox 下拉選單

prefix_var = tk.StringVar()

prefix_combobox = ttk.Combobox(root, textvariable=prefix_var, values=prefixes, state="readonly")

prefix_combobox.grid(row=1, column=0, padx=10, pady=10)

root_var = tk.StringVar()

root_combobox = ttk.Combobox(root, textvariable=root_var, values=roots, state="readonly")

root_combobox.grid(row=1, column=1, padx=10, pady=10)

suffix_var = tk.StringVar()

suffix_combobox = ttk.Combobox(root, textvariable=suffix_var, values=suffixes, state="readonly")

suffix_combobox.grid(row=1, column=2, padx=10, pady=10)

# 顯示組合後的單字

word_label = tk.Label(root, text="", font=("Arial", 14, "bold"), fg="blue")

word_label.grid(row=4, column=1, padx=10, pady=10)

# 更新單字的函式

def update_word():

combined_word = f"{prefix_var.get()}{root_var.get()}{suffix_var.get()}"

word_label.config(text=combined_word)

engine.say(combined_word)

engine.runAndWait()

# 隨機生成 10 個單字並朗讀

def generate_random_words():

words = [f"{random.choice(prefixes)}{random.choice(roots)}{random.choice(suffixes)}" for _ in range(10)]

word_label.config(text="\n".join(words))

for word in words:

engine.say(word)

engine.runAndWait()

# 設定按鈕，點擊後更新顯示

combine_button = tk.Button(root, text="組合單字", command=update_word)

combine_button.grid(row=3, column=1, padx=10, pady=10)

# 設定隨機練習按鈕

auto_practice_button = tk.Button(root, text="自動練習 10 字", command=generate_random_words)

auto_practice_button.grid(row=5, column=1, padx=10, pady=10)

# 啟動主循環

root.mainloop()

組字練習 II

import tkinter as tk

from tkinter import ttk

import pyttsx3

engine = pyttsx3.init()

# 字首、字根、字尾選項

t ='ante,contra,contro,counter,a,auto,bene,con,co,com,col,de,en,ex,extra,homo,hyper,in,im,inter,intra,intro,mal,micro,mono,multi,ob,op,para,per,poly,re,semi,sub,sup,super,supra,sur,sym,syn,tele,trans,anti,dis,ab,in,il,ir,im'

t = t.split(',')

t.sort()

prefixes = t

t1 = 'ann,audi,bio,cap,ceive,cip,cept,ced,ceed,cess,cede,circ,cyc,dem,demo,dict,divid,duc,equ,flect,flex,form,gram,graph,gress,ject,manu,mob,mot,mov,nov,ped,pict,port,pos,press,rupt,scribe,serve,sist,spec,spir,spire,tain,tract,vid,vise,viv,volv,volute,uni,bi,tri,oct,deca,cent,kilo,mega'

t1 = t1.split(',')

t1.sort()

roots = t1

t2 = 'er,or,an,ian,ant,ent,ar,ate,ee,eer,ese,ess,ic,ician,ist,ster,al,age,ance,ence,ancy,ency,dom,hood,ic(s),ism,ity,ty,logy,ment,ness,ory,ship,tion,ation,sion,ure,ture,ate,en,fy,ify,ish,ize,ise,le,able,ible,al,ant,ent,ar,ary,ate,en,ful,ic,ical,id,ior,ish,ive,less,like,ly,ous,proof,ward,y,ly,ward(s),way(s),wise'

t2 = t2.split(',')

t2.sort()

suffixes = t2

# 建立主視窗

root = tk.Tk()

root.title("字根組合器")

root.geometry("550x250")

# 設定標籤

tk.Label(root, text="選擇字首:").grid(row=0, column=0, padx=10, pady=10)

tk.Label(root, text="選擇字根:").grid(row=0, column=1, padx=10, pady=10)

tk.Label(root, text="選擇字尾:").grid(row=0, column=2, padx=10, pady=10)

tk.Label(root, text="組合的單字:").grid(row=4, column=0, padx=10, pady=10)

# 建立 Combobox 下拉選單

prefix_var = tk.StringVar()

prefix_combobox = ttk.Combobox(root, textvariable=prefix_var, values=prefixes, state="readonly")

prefix_combobox.grid(row=1, column=0, padx=10, pady=10)

root_var = tk.StringVar()

root_combobox = ttk.Combobox(root, textvariable=root_var, values=roots, state="readonly")

root_combobox.grid(row=1, column=1, padx=10, pady=10)

suffix_var = tk.StringVar()

suffix_combobox = ttk.Combobox(root, textvariable=suffix_var, values=suffixes, state="readonly")

suffix_combobox.grid(row=1, column=2, padx=10, pady=10)

# 顯示組合後的單字

word_label = tk.Label(root, text="", font=("Arial", 14, "bold"), fg="blue")

word_label.grid(row=4, column=1, padx=10, pady=10)

# 更新單字的函式

def update_word():

prefix = prefix_var.get()

root_word = root_var.get()

suffix = suffix_var.get()

combined_word = f"{prefix}{root_word}{suffix}"

word_label.config(text=combined_word)

engine.say(combined_word)

engine.runAndWait()

# 設定按鈕，點擊後更新顯示

combine_button = tk.Button(root, text="組合單字", command=update_word)

combine_button.grid(row=3, column=1, padx=10, pady=10)

# 啟動主循環

root.mainloop()

2025年3月10日星期一

Combobox 下拉選單

import tkinter as tk

from tkinter import ttk

# 字首、字根、字尾選項

prefixes = ["pre", "un", "re", "dis"]

roots = ["dict", "form", "struct", "spect"]

suffixes = ["ion", "able", "ive", "ment"]

# 建立主視窗

root = tk.Tk()

root.title("字根組合器")

root.geometry("400x250")

# 設定標籤

tk.Label(root, text="選擇字首:").grid(row=0, column=0, padx=10, pady=10)

tk.Label(root, text="選擇字根:").grid(row=1, column=0, padx=10, pady=10)

tk.Label(root, text="選擇字尾:").grid(row=2, column=0, padx=10, pady=10)

tk.Label(root, text="組合的單字:").grid(row=4, column=0, padx=10, pady=10)

# 建立 Combobox 下拉選單

prefix_var = tk.StringVar()

prefix_combobox = ttk.Combobox(root, textvariable=prefix_var, values=prefixes, state="readonly")

prefix_combobox.grid(row=0, column=1, padx=10, pady=10)

root_var = tk.StringVar()

root_combobox = ttk.Combobox(root, textvariable=root_var, values=roots, state="readonly")

root_combobox.grid(row=1, column=1, padx=10, pady=10)

suffix_var = tk.StringVar()

suffix_combobox = ttk.Combobox(root, textvariable=suffix_var, values=suffixes, state="readonly")

suffix_combobox.grid(row=2, column=1, padx=10, pady=10)

# 顯示組合後的單字

word_label = tk.Label(root, text="", font=("Arial", 14, "bold"), fg="blue")

word_label.grid(row=4, column=1, padx=10, pady=10)

# 更新單字的函式

def update_word():

prefix = prefix_var.get()

root_word = root_var.get()

suffix = suffix_var.get()

combined_word = f"{prefix}{root_word}{suffix}"

word_label.config(text=combined_word)

# 設定按鈕，點擊後更新顯示

combine_button = tk.Button(root, text="組合單字", command=update_word)

combine_button.grid(row=3, column=1, padx=10, pady=10)

# 啟動主循環

root.mainloop()

字首字根字尾組字練習

import tkinter as tk

from tkinter import ttk

import pyttsx3

import requests

from bs4 import BeautifulSoup

def build_word():

prefix = prefix_var.get()

root = root_var.get()

suffix = suffix_var.get()

if prefix in prefixes and root in roots and suffix in suffixes:

word = prefix + root + suffix

meaning = f"{prefixes[prefix]} + {roots[root]} + {suffixes[suffix]}"

chinese_meaning = f"{prefix_ch[prefix]} + {root_ch[root]} + {suffix_ch[suffix]}"

dictionary_meaning = fetch_yahoo_definition(word)

result_label.config(text=f"你的新單字: {word}\n英文解釋: {meaning}\n中文解釋: {chinese_meaning}\n字典解釋: {dictionary_meaning}")

speak_word(word)

else:

result_label.config(text="無效的組合，請選擇有效的選項。")

def speak_word(word):

engine = pyttsx3.init()

engine.say(word)

engine.runAndWait()

def fetch_yahoo_definition(word):

try:

url = f"https://tw.dictionary.search.yahoo.com/search?p={word}"

headers = {"User-Agent": "Mozilla/5.0"}

response = requests.get(url, headers=headers)

soup = BeautifulSoup(response.text, "html.parser")

definition = soup.find("span", class_="fz-14 lh-22").text if soup.find("span", class_="fz-14 lh-22") else "無字典解釋"

return definition

except:

return "查詢失敗，請檢查網絡。"

prefixes = {

"un": "not, opposite of",

"re": "again, back",

"pre": "before",

"mis": "wrongly",

"dis": "opposite of",

"sub": "under, below",

"inter": "between",

"auto": "self",

"trans": "across"

}

prefix_ch = {

"un": "不，相反的",

"re": "再，回",

"pre": "前，預先",

"mis": "錯誤地",

"dis": "相反的",

"sub": "下，次級",

"inter": "之間",

"auto": "自己",

"trans": "跨，穿越"

}

roots = {

"act": "do, perform",

"form": "shape",

"ject": "throw",

"port": "carry",

"rupt": "break",

"scribe": "write",

"struct": "build",

"vis": "see",

"dict": "say"

}

root_ch = {

"act": "行動，執行",

"form": "形狀，形成",

"ject": "投擲，拋",

"port": "運輸，攜帶",

"rupt": "破壞，中斷",

"scribe": "書寫，記錄",

"struct": "建造，結構",

"vis": "看，視覺",

"dict": "說話，命令"

}

suffixes = {

"er": "one who",

"able": "capable of",

"ion": "act, process",

"ment": "state or quality",

"ful": "full of",

"less": "without",

"ness": "state of being",

"ity": "quality of",

"ive": "tending to"

}

suffix_ch = {

"er": "從事...的人",

"able": "能夠...的",

"ion": "行為，過程",

"ment": "狀態，品質",

"ful": "充滿...的",

"less": "沒有...的",

"ness": "狀態，性質",

"ity": "品質，特性",

"ive": "具有...性質的"

}

root = tk.Tk()

root.geometry("600x300")

root.title("字首字根字尾組字練習")

tk.Label(root, text="字首").grid(row=0, column=0, padx=20)

tk.Label(root, text="字根").grid(row=0, column=1, padx=20)

tk.Label(root, text="字尾").grid(row=0, column=2, padx=20)

prefix_var = tk.StringVar()

root_var = tk.StringVar()

suffix_var = tk.StringVar()

prefix_menu = ttk.Combobox(root, textvariable=prefix_var, values=list(prefixes.keys()))

prefix_menu.grid(row=1, column=0, padx=20)

root_menu = ttk.Combobox(root, textvariable=root_var, values=list(roots.keys()))

root_menu.grid(row=1, column=1, padx=20)

suffix_menu = ttk.Combobox(root, textvariable=suffix_var, values=list(suffixes.keys()))

suffix_menu.grid(row=1, column=2, padx=20)

tk.Button(root, text="組字", command=build_word).grid(row=4, column=0, columnspan=3, pady=10)

result_label = tk.Label(root, text="", wraplength=500, justify="left")

result_label.grid(row=5, column=0, columnspan=3, pady=10)

root.mainloop()

2025年3月7日星期五

Python 讀寫 SQLite（Docker 最簡單範例）

這是一個 最簡單的 Python 程式，可以在 Docker 容器中讀取與寫入 SQLite 資料庫。

1. 建立專案目錄

首先，在 Windows 命令提示字元 (cmd) 或 PowerShell 建立專案資料夾：

mkdir C:\sqlite_docker
cd C:\sqlite_docker

2. 建立 Python 讀寫 SQLite 檔案

在 C:\sqlite_docker 內建立 app.py：

import sqlite3

# 設定 SQLite 資料庫檔案
DB_FILE = "test.db"

# 連接資料庫（如果不存在則自動建立）
conn = sqlite3.connect(DB_FILE)
cursor = conn.cursor()

# 建立表格（如果不存在）
cursor.execute('''
    CREATE TABLE IF NOT EXISTS messages (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        text TEXT NOT NULL
    )
''')

# 插入測試資料
cursor.execute("INSERT INTO messages (text) VALUES (?)", ("Hello, SQLite in Docker!",))
conn.commit()

# 讀取所有資料
cursor.execute("SELECT * FROM messages")
rows = cursor.fetchall()

# 顯示結果
print("=== SQLite 資料庫內容 ===")
for row in rows:
    print(row)

# 關閉連接
conn.close()

3. 建立 Dockerfile

在 C:\sqlite_docker 內建立 Dockerfile：

# 使用 Python 3.10 作為基礎映像
FROM python:3.10

# 設定工作目錄
WORKDIR /app

# 複製當前目錄的所有檔案到容器內
COPY . .

# 安裝 SQLite3（Python 內建支援，不需要額外安裝）
# 確保資料庫文件存在
RUN touch test.db

# 執行 Python 腳本
CMD ["python", "app.py"]

4. 建立 Docker 映像檔

回到 PowerShell，進入 C:\sqlite_docker：

cd C:\sqlite_docker

執行：

docker build -t sqlite_test .

這會 建立 Docker 映像檔，名稱為 sqlite_test。

5. 運行 Docker 容器

docker run --rm -v C:\sqlite_docker:/app sqlite_test

這樣：

--rm：執行結束後自動刪除容器
-v C:\sqlite_docker:/app：將本機目錄掛載到容器，確保 SQLite 資料庫 test.db 可持久保存

預期輸出：

=== SQLite 資料庫內容 ===
(1, 'Hello, SQLite in Docker!')

這代表：

成功建立 test.db
寫入了一筆測試數據
成功讀取數據

6. 檢查 SQLite 資料庫

如果你想檢查 test.db 內的內容，執行：

sqlite3 C:\sqlite_docker\test.db

然後在 SQLite 交互模式中輸入：

SELECT * FROM messages;

你應該會看到：

1|Hello, SQLite in Docker!

輸入 .exit 離開 SQLite。

7. 停止 & 刪除容器

因為我們用了 --rm，所以容器執行完畢後會自動刪除。如果你想讓容器持續運行，請改用：

docker run -d -p 5000:5000 -v C:\sqlite_docker:/app sqlite_test

然後用：

docker ps

來查看運行中的容器。

🚀 總結

✅ 這個範例使用 Python 讀寫 SQLite，並執行在 Docker 容器中
✅ SQLite 資料庫 (test.db) 存放在本機 (C:\sqlite_docker)，確保資料不會因容器刪除而遺失
✅ Dockerfile 非常簡單，只需 Python + SQLite 即可運行

這樣你的 Python + SQLite + Docker 最簡單範例就完成了！🚀

Flask 留言板（留言存入檔案 + Docker 版本）

這個 Flask 留言板不僅能提交留言，還會 將留言儲存至檔案 (messages.txt)，讓留言可以保留。

1. 建立 Flask 留言板

1.1 建立 `app.py`

在 C:\flask_board 目錄內，建立 app.py：

from flask import Flask, request, render_template
import os

app = Flask(__name__)

# 設定留言儲存檔案
MESSAGE_FILE = "messages.txt"

# 確保檔案存在
if not os.path.exists(MESSAGE_FILE):
    open(MESSAGE_FILE, "w").close()

# 讀取留言
def load_messages():
    messages = []
    with open(MESSAGE_FILE, "r", encoding="utf-8") as file:
        for line in file:
            parts = line.strip().split(":", 1)
            if len(parts) == 2:
                messages.append({'name': parts[0], 'message': parts[1]})
    return messages

# 儲存留言
def save_message(name, message):
    with open(MESSAGE_FILE, "a", encoding="utf-8") as file:
        file.write(f"{name}: {message}\n")

@app.route('/', methods=['GET', 'POST'])
def index():
    if request.method == 'POST':
        name = request.form.get('name')
        message = request.form.get('message')
        if name and message:
            save_message(name, message)
    messages = load_messages()
    return render_template('index.html', messages=messages)

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

這個 Flask 應用做了什麼？

留言存到 messages.txt。
讀取檔案內容顯示留言。
確保留言不會因為重啟 Flask 而消失。

1.2 建立 `templates/index.html`

在 C:\flask_board\templates 目錄內，建立 index.html：

<!DOCTYPE html>
<html lang="zh">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Flask 留言板</title>
</head>
<body>
    <h1>Flask 留言板</h1>
    <form method="post">
        <label>姓名：</label>
        <input type="text" name="name" required>
        <br>
        <label>留言：</label>
        <textarea name="message" required></textarea>
        <br>
        <button type="submit">提交留言</button>
    </form>

    <h2>留言列表</h2>
    <ul>
        {% for msg in messages %}
            <li><strong>{{ msg.name }}</strong>: {{ msg.message }}</li>
        {% endfor %}
    </ul>
</body>
</html>

這個 HTML：

提供表單讓使用者提交留言
顯示所有留言

2. 建立 Dockerfile

在 C:\flask_board 內，建立 Dockerfile：

# 使用 Python 3.10 作為基礎映像
FROM python:3.10

# 設定工作目錄
WORKDIR /app

# 複製當前目錄的所有檔案到容器內
COPY . .

# 安裝 Flask
RUN pip install flask

# 設定留言存儲檔案（確保 messages.txt 存在）
RUN touch messages.txt

# 啟動 Flask 伺服器
CMD ["python", "app.py"]

3. 建立 Docker 映像檔

回到 PowerShell，進入 C:\flask_board：

cd C:\flask_board

執行：

docker build -t flask_board .

這會 建立 Docker 映像檔，名稱為 flask_board。

4. 運行 Flask 容器

執行：

docker run -d -p 5000:5000 -v C:\flask_board:/app flask_board

這樣：

-d：讓 Flask 在背景運行
-p 5000:5000：將本機 5000 port 對應到 Docker 內的 Flask 伺服器
-v C:\flask_board:/app：掛載本機資料夾到 Docker 容器，確保留言檔案持久化

5. 訪問 Flask 留言板

打開 瀏覽器，訪問：

http://localhost:5000/

輸入姓名 & 留言
點擊提交
留言會寫入 messages.txt，並顯示在頁面上
重啟容器後，留言仍然存在！

6. 如何更新 Flask 應用？

如果你修改 app.py 或 index.html，只要 重啟容器，不用重新 build：

docker restart <容器ID>

如果你 修改了 Dockerfile，則需要：

docker stop <容器ID>
docker rm <容器ID>
docker build -t flask_board .
docker run -d -p 5000:5000 -v C:\flask_board:/app flask_board

7. 停止 & 刪除容器

如果你想停止 Flask 伺服器：

docker ps          # 找到運行中的容器 ID
docker stop <容器ID>

如果要刪除容器：

docker rm <容器ID>

如果要刪除 Docker 映像：

docker rmi flask_board

這個版本的 Flask 留言板： ✅ 留言存到檔案 (messages.txt)，可持久化
✅ 使用 Docker 容器運行
✅ Volume 掛載，修改內容不需要重建映像檔

這樣你的 Flask 留言板就完整了！🚀

Flask 留言板（Docker 版本）

簡單 Flask 留言板（Docker 版本）

這是一個 最簡單的 Flask 留言板，使用 Flask + Docker，讓使用者可以提交留言並顯示留言列表。

1. 準備 Flask 應用

1.1 建立專案資料夾

在 Windows 上，開啟 PowerShell 或 cmd，執行：

mkdir C:\flask_board
cd C:\flask_board

這會建立 C:\flask_board 目錄，並進入該目錄。

1.2 建立 `app.py`

在 C:\flask_board 目錄內，建立 app.py，內容如下：

from flask import Flask, request, render_template

app = Flask(__name__)

# 簡單的留言存儲（不使用資料庫）
messages = []

@app.route('/', methods=['GET', 'POST'])
def index():
    if request.method == 'POST':
        name = request.form.get('name')
        message = request.form.get('message')
        if name and message:
            messages.append({'name': name, 'message': message})
    return render_template('index.html', messages=messages)

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

這個 Flask 應用：

GET 方法：顯示留言列表
POST 方法：提交留言並存儲到 messages（記憶體中）

1.3 建立 `templates/index.html`

在 C:\flask_board\templates 目錄內，建立 index.html：

<!DOCTYPE html>
<html lang="zh">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>簡單 Flask 留言板</title>
</head>
<body>
    <h1>留言板</h1>
    <form method="post">
        <label>姓名：</label>
        <input type="text" name="name" required>
        <br>
        <label>留言：</label>
        <textarea name="message" required></textarea>
        <br>
        <button type="submit">提交留言</button>
    </form>
    
    <h2>留言列表</h2>
    <ul>
        {% for msg in messages %}
            <li><strong>{{ msg.name }}</strong>: {{ msg.message }}</li>
        {% endfor %}
    </ul>
</body>
</html>

這個頁面：

提供表單讓使用者提交 姓名 + 留言
顯示所有留言

2. 建立 Dockerfile

在 C:\flask_board 內，建立 Dockerfile：

# 使用 Python 3.10 作為基礎映像
FROM python:3.10

# 設定工作目錄
WORKDIR /app

# 複製當前目錄的所有檔案到容器內
COPY . .

# 安裝 Flask
RUN pip install flask

# 啟動 Flask 伺服器
CMD ["python", "app.py"]

3. 建立 Docker 映像檔

回到 PowerShell，進入 C:\flask_board：

cd C:\flask_board

執行：

docker build -t flask_board .

這會根據 Dockerfile 建立 Docker 映像檔，名稱為 flask_board。

4. 運行 Flask 容器

執行：

docker run -d -p 5000:5000 flask_board

這會：

-d：讓 Flask 在背景運行
-p 5000:5000：將本機 5000 port 對應到 Docker 內的 Flask 伺服器

5. 訪問 Flask 留言板

打開 瀏覽器，訪問：

http://localhost:5000/

你可以：

輸入姓名 & 留言
點擊提交
留言會顯示在下方列表

6. 修改 Flask 應用後，如何更新？

6.1 停止並刪除舊容器

docker ps          # 找到正在運行的容器 ID
docker stop <容器ID>
docker rm <容器ID>

6.2 重新建置映像

docker build -t flask_board .

6.3 重新運行

docker run -d -p 5000:5000 flask_board

7. 即時開發模式（Volume 掛載）

如果你不想每次修改 Flask 程式後都要重建映像檔，可以使用 Volume 掛載：

docker run -d -p 5000:5000 -v C:\flask_board:/app flask_board

這樣你只要修改 app.py，Flask 伺服器就會即時讀取變更 （適用開發模式）。

8. 停止 & 刪除容器

如果你想停止 Flask 伺服器：

docker ps          # 找到運行中的容器 ID
docker stop <容器ID>

如果要刪除容器：

docker rm <容器ID>

如果要刪除 Docker 映像：

docker rmi flask_board

這是一個 最簡單的 Flask 留言板，可以幫助你快速建立 Flask 應用並用 Docker 執行！🚀

修改 Web 後重新發佈

修改 Web 內容後，如何重新發佈？

當你修改 app.py 或其他 Web 內容後，需要重新 建置 Docker 映像檔 並 重新部署容器。

步驟 1：修改 Web 內容

例如，你要修改 app.py 讓網頁顯示不同的內容：

from flask import Flask

app = Flask(__name__)

@app.route('/')
def home():
    return "<h1>Updated: Hello, Docker Web! 🚀</h1>"

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

步驟 2：刪除舊容器

先找到正在運行的容器：

docker ps

如果你的 mywebapp 容器正在運行，先停止並刪除：

docker stop <容器ID>
docker rm <容器ID>

（<容器ID> 請用 docker ps 查到的 ID 來替換）

步驟 3：重新建置 Docker 映像檔

執行：

docker build -t mywebapp .

這會根據修改後的 app.py 重新產生新的 Docker 映像檔。

步驟 4：重新運行容器

docker run -d -p 5000:5000 mywebapp

然後在瀏覽器重新打開：

http://localhost:5000/

你應該會看到更新後的內容：

Updated: Hello, Docker Web! 🚀

快速更新的方法（開發模式）

如果你不想每次都重建映像檔，開發時可以 掛載本機目錄，讓容器即時載入修改：

docker run -d -p 5000:5000 -v C:\docker_web:/app mywebapp

這樣你修改 app.py 後，只要重啟容器即可：

docker restart <容器ID>

這種方式適合開發階段，正式環境仍建議重新 docker build 來確保變更生效。

這樣，你的 Docker Web 內容就能快速更新並重新發佈！🚀

Docker + Python Flask 簡單 Web 伺服器

最簡單的 Docker 網頁應用

這是一個 最簡單的 Docker 靜態網頁伺服器，透過 Docker + Python Flask 建立一個簡單的 Web 伺服器，並執行在 Docker 容器中。

1. 準備專案

首先，在你的 Windows 檔案總管建立一個新資料夾，例如 C:\docker_web，然後開啟 PowerShell 或 命令提示字元 (cmd)，進入這個資料夾：

cd C:\docker_web

2. 建立 Flask 應用程式

在 C:\docker_web 目錄內，建立 app.py，內容如下：

from flask import Flask

app = Flask(__name__)

@app.route('/')
def home():
    return "<h1>Hello, Docker Web!</h1>"

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

這是一個最簡單的 Flask 網頁伺服器，它在 http://localhost:5000/ 顯示 Hello, Docker Web!。

3. 建立 Dockerfile

在 C:\docker_web 內，建立 Dockerfile，內容如下：

# 使用 Python 3.10 作為基礎映像
FROM python:3.10

# 設定工作目錄
WORKDIR /app

# 複製當前目錄的所有檔案到容器內
COPY . .

# 安裝 Flask
RUN pip install flask

# 啟動 Flask 伺服器
CMD ["python", "app.py"]

4. 建立 Docker 映像檔

在 C:\docker_web 內執行以下指令：

docker build -t mywebapp .

這會根據 Dockerfile 建立一個 Docker 映像檔，名稱為 mywebapp。

5. 運行 Docker 容器

運行以下指令：

docker run -d -p 5000:5000 mywebapp

這表示：

-d：背景運行（detached mode）
-p 5000:5000：將容器內的 5000 埠對應到本機 5000 埠
mywebapp：要執行的 Docker 映像

6. 開啟網頁

打開瀏覽器，訪問：

http://localhost:5000/

你應該會看到：

Hello, Docker Web!

7. 停止與刪除容器

如果要停止容器，可以執行：

docker ps   # 查找運行中的容器 ID
docker stop <容器ID>  # 停止容器

如果要刪除容器：

docker rm <容器ID>

8. 常用 Docker 指令

指令	說明
`docker build -t mywebapp .`	建立 Docker 映像檔
`docker images`	查看所有本地映像
`docker run -d -p 5000:5000 mywebapp`	運行 Flask 伺服器
`docker ps`	查看正在運行的容器
`docker stop <容器ID>`	停止容器
`docker rm <容器ID>`	刪除容器
`docker rmi mywebapp`	刪除映像檔

這是一個 最簡單的 Docker 網頁範例，希望對你有幫助！🚀

Windows Docker 最簡入門實作

如果你使用的是 Windows OS，這裡是 Docker 最簡入門實作，讓你快速上手。

1. 安裝 Docker Desktop

1.1 下載並安裝

下載連結：Docker Desktop for Windows
安裝條件
- Windows 10/11 64-bit
- 啟用 Hyper-V 和 WSL 2（安裝時 Docker 會引導設定）

1.2 驗證安裝

打開 PowerShell 或 命令提示字元 (cmd)，輸入：

docker --version

如果安裝成功，你會看到類似：

Docker version 24.0.2, build cb74dfc

2. 運行第一個 Docker 容器

2.1 拉取 Python 映像檔

在 PowerShell 或 命令提示字元 (cmd) 中輸入：

docker pull python:3.10

這將下載 Python 3.10 官方映像檔。

2.2 運行 Python 容器

執行以下指令：

docker run -it --name mypython python:3.10

成功後，你會看到：

Python 3.10.12 (default, Jun  6 2023, 00:00:00)
[GCC 10.2.1 20210130] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>

輸入：

print("Hello, Docker!")

然後輸入 exit() 或 Ctrl+D 來退出。

3. 建立自己的 Docker 映像檔

3.1 建立專案目錄

在 Windows 桌面 (Desktop) 或 C:\Users\你的帳號 底下，建立一個新資料夾：

mkdir C:\docker_demo
cd C:\docker_demo

3.2 建立 Python 檔案

使用記事本或 VS Code 建立 app.py：

# app.py
print("Hello, this is my first Docker app on Windows!")

3.3 建立 Dockerfile

在 C:\docker_demo 內建立 Dockerfile：

# 使用 Python 3.10 基礎映像檔
FROM python:3.10

# 設定容器內的工作目錄
WORKDIR /app

# 複製 Python 檔案到容器內
COPY app.py .

# 設定啟動指令
CMD ["python", "app.py"]

3.4 建立 Docker 映像檔

開啟 PowerShell，進入 C:\docker_demo 目錄：

cd C:\docker_demo

執行：

docker build -t mypythonapp .

成功後，執行：

docker images

你應該會看到 mypythonapp 出現在列表中。

3.5 執行容器

運行你的應用：

docker run mypythonapp

輸出應該會是：

Hello, this is my first Docker app on Windows!

4. 常見 Docker 指令（Windows）

指令	說明
`docker pull python:3.10`	下載 Python 3.10 映像檔
`docker run -it --name mypython python:3.10`	執行 Python 容器
`docker ps`	查看目前運行中的容器
`docker ps -a`	查看所有容器（包含已停止的）
`docker images`	查看本機映像檔
`docker stop 容器ID`	停止容器
`docker rm 容器ID`	刪除容器
`docker rmi 映像檔ID`	刪除映像檔

這是 Windows OS 上的 Docker 最簡入門實作，讓你快速學會如何建立與運行 Docker 容器 🚀

python tkinter canvas sample

import tkinter as tk

import random

def change_color():
    """隨機改變矩形顏色"""
    colors = ["red", "blue", "green", "purple", "orange"]
    new_color = random.choice(colors)
    canvas.itemconfig(rect, fill=new_color)

def draw_point(event):
    """在點擊的位置畫一個小圓點"""
    x, y = event.x, event.y  # 獲取滑鼠點擊的位置
    colors = ["black", "red", "blue", "green", "purple"]
    color = random.choice(colors)  # 隨機顏色
    r = 3  # 點的半徑
    canvas.create_oval(x-r, y-r, x+r, y+r, fill=color, outline=color)

# 建立主視窗
root = tk.Tk()
root.title("Canvas 畫布")

# 建立 Canvas
canvas = tk.Canvas(root, width=400, height=300, bg="white")
canvas.pack()

# **繪製圖形**
# 畫一條線
canvas.create_line(50, 50, 350, 150, fill="red", width=3)

# 畫一個矩形（可點擊變色）
rect = canvas.create_rectangle(50, 50, 150, 150, outline="blue", width=2, fill="lightblue")

# 畫一個圓形（橢圓）
canvas.create_oval(180, 50, 250, 120, outline="green", width=2)

# 畫一個多邊形（三角形）
canvas.create_polygon(200, 200, 300, 200, 250, 100, outline="purple", fill="yellow", width=2)

# 畫文字
canvas.create_text(200, 250, text="Hello, Tkinter! 視窗工具", font=("Arial", 16), fill="black")

# **點擊矩形改變顏色**
canvas.tag_bind(rect, "<Button-1>", lambda event: change_color())

# **點擊畫布時，繪製小圓點**
canvas.bind("<Button-1>", draw_point)

# 啟動主迴圈
root.mainloop()

tkinter windows form sample

import tkinter as tk

from tkinter.constants import CENTER

def plus():

print("你點擊了按鈕")

window = tk.Tk()

window.title('GUI')

window.config(bg="lightyellow")

window.geometry('380x400')

window.resizable(False, False)

test = tk.Button(text="結帳",command=plus,bg="blue",fg="white",font=('標楷體', 16, "bold"))

# test.pack(side="bottom")

test.place(x=330,y=360,anchor=CENTER)

window.mainloop()

Tkinter 選單範例

這是一個 Tkinter Menu 的完整範例，展示如何建立選單，包括 主選單、下拉選單、子選單、分隔線、快捷鍵，以及 "關於" 對話框。

完整 Tkinter 選單範例

import tkinter as tk
from tkinter import messagebox

# 創建主視窗
root = tk.Tk()
root.title("Tkinter Menu 範例")
root.geometry("400x300")

# 創建主選單
menu_bar = tk.Menu(root)

# **檔案 (File) 選單**
file_menu = tk.Menu(menu_bar, tearoff=0)
file_menu.add_command(label="開啟 (Ctrl+O)", command=lambda: messagebox.showinfo("開啟", "開啟檔案"))
file_menu.add_command(label="儲存 (Ctrl+S)", command=lambda: messagebox.showinfo("儲存", "儲存檔案"))
file_menu.add_separator()
file_menu.add_command(label="離開 (Ctrl+Q)", command=root.quit)  # 離開應用程式

menu_bar.add_cascade(label="檔案 (File)", menu=file_menu)

# **編輯 (Edit) 選單**
edit_menu = tk.Menu(menu_bar, tearoff=0)
edit_menu.add_command(label="剪下 (Ctrl+X)", command=lambda: messagebox.showinfo("剪下", "剪下文字"))
edit_menu.add_command(label="複製 (Ctrl+C)", command=lambda: messagebox.showinfo("複製", "複製文字"))
edit_menu.add_command(label="貼上 (Ctrl+V)", command=lambda: messagebox.showinfo("貼上", "貼上文字"))

menu_bar.add_cascade(label="編輯 (Edit)", menu=edit_menu)

# **說明 (Help) 選單**
help_menu = tk.Menu(menu_bar, tearoff=0)
help_menu.add_command(label="關於 (About)", command=lambda: messagebox.showinfo("關於", "這是一個 Tkinter 範例"))
menu_bar.add_cascade(label="說明 (Help)", menu=help_menu)

# **設定主選單**
root.config(menu=menu_bar)

# **鍵盤快捷鍵 (熱鍵)**
root.bind("<Control-o>", lambda event: messagebox.showinfo("開啟", "快捷鍵 - 開啟檔案"))
root.bind("<Control-s>", lambda event: messagebox.showinfo("儲存", "快捷鍵 - 儲存檔案"))
root.bind("<Control-q>", lambda event: root.quit)

# 執行主視窗
root.mainloop()

功能解釋

1️⃣ 主選單 `menu_bar`

menu_bar = tk.Menu(root)：創建主選單。
root.config(menu=menu_bar)：將選單設定到視窗。

2️⃣ `File` (檔案) 選單

file_menu = tk.Menu(menu_bar, tearoff=0)：創建子選單，tearoff=0 禁用分離選單。
add_command(label="開啟", command=...)：添加功能選項。
add_separator()：添加分隔線。
file_menu.add_command(label="離開", command=root.quit)：點擊後關閉應用程式。

3️⃣ `Edit` (編輯) 選單

包含 剪下、複製、貼上 功能。

4️⃣ `Help` (說明) 選單

包含 "關於"，點擊後顯示 messagebox.showinfo()。

5️⃣ 鍵盤快捷鍵

root.bind("<Control-o>", lambda event: ...) 綁定 Ctrl+O 快捷鍵。
root.bind("<Control-s>", lambda event: ...) 綁定 Ctrl+S 快捷鍵。
root.bind("<Control-q>", lambda event: root.quit) 綁定 Ctrl+Q 快速退出程式。

額外擴展

你可以加入更多 子選單，例如：

submenu = tk.Menu(file_menu, tearoff=0)
submenu.add_command(label="最近開啟的檔案 1")
submenu.add_command(label="最近開啟的檔案 2")
file_menu.add_cascade(label="最近開啟", menu=submenu)

這樣 File 選單中會有一個 "最近開啟" 的 子選單。

完整 Tkinter GUI 範例

這裡是包含 Frame、Checkbutton、Radiobutton 和 Listbox 的完整 Tkinter 例子，展示如何組織這些元件並讓它們互動。

完整 Tkinter GUI 範例

這個程式會： ✅ 使用 Frame 來組織 UI
✅ 添加 Checkbutton 來讓使用者選擇選項
✅ 添加 Radiobutton 來選擇單一選項
✅ 使用 Listbox 來顯示多個選擇

import tkinter as tk
from tkinter import messagebox

# 建立主視窗
root = tk.Tk()
root.title("Tkinter Frame, Checkbutton, Radiobutton, Listbox 範例")
root.geometry("400x400")

# 創建 Frame 容器
frame = tk.Frame(root, padx=10, pady=10, relief="groove", borderwidth=2)
frame.pack(pady=10)

# **Checkbutton**
def show_check():
    selected_options = [var1.get(), var2.get()]
    messagebox.showinfo("勾選框選擇", f"你選擇了: {', '.join([x for x in selected_options if x])}")

tk.Label(frame, text="請選擇你的興趣:", font=("Arial", 12)).pack(anchor="w")

var1 = tk.StringVar()
var2 = tk.StringVar()

check1 = tk.Checkbutton(frame, text="音樂", variable=var1, onvalue="音樂", offvalue="")
check2 = tk.Checkbutton(frame, text="運動", variable=var2, onvalue="運動", offvalue="")
check1.pack(anchor="w")
check2.pack(anchor="w")

btn_check = tk.Button(frame, text="確認選擇", command=show_check)
btn_check.pack(pady=5)

# **Radiobutton**
def show_radio():
    messagebox.showinfo("單選按鈕選擇", f"你選擇了: {radio_var.get()}")

tk.Label(root, text="請選擇你的性別:", font=("Arial", 12)).pack()

radio_var = tk.StringVar(value="男")  # 預設選項
radio1 = tk.Radiobutton(root, text="男", variable=radio_var, value="男")
radio2 = tk.Radiobutton(root, text="女", variable=radio_var, value="女")
radio1.pack()
radio2.pack()

btn_radio = tk.Button(root, text="確認選擇", command=show_radio)
btn_radio.pack(pady=5)

# **Listbox**
def show_listbox():
    selected_items = [listbox.get(i) for i in listbox.curselection()]
    messagebox.showinfo("清單框選擇", f"你選擇了: {', '.join(selected_items)}")

tk.Label(root, text="請選擇你的最愛食物:", font=("Arial", 12)).pack()
listbox = tk.Listbox(root, selectmode=tk.MULTIPLE)
foods = ["Pizza", "壽司", "牛排", "炸雞", "沙拉"]
for food in foods:
    listbox.insert(tk.END, food)
listbox.pack()

btn_listbox = tk.Button(root, text="確認選擇", command=show_listbox)
btn_listbox.pack(pady=5)

# 進入主迴圈
root.mainloop()

程式功能解釋

Frame
- frame = tk.Frame(root, padx=10, pady=10, relief="groove", borderwidth=2)
- Frame 主要用來包裝 Checkbutton 這部分，增加邊框，組織 UI 佈局。
Checkbutton
- Checkbutton 可多選，使用 StringVar() 來存放狀態值。
- onvalue 設定為選擇時的值，offvalue 設定為未選擇時的值。
- messagebox.showinfo() 會顯示選擇結果。
Radiobutton
- 只允許單選，使用 StringVar() 存放值。
- 預設 radio_var = tk.StringVar(value="男")。
- 當使用者點擊「確認選擇」按鈕時，會彈出選擇的內容。
Listbox
- 使用 selectmode=tk.MULTIPLE 允許多選。
- curselection() 取得所有被選取的索引，然後用 .get() 取出值。
- 按下按鈕時，會顯示選擇的清單項目。

這個範例展示了 Frame、Checkbutton、Radiobutton 和 Listbox 的基本用法，適合用來建立簡單的表單、偏好設定選單等。你可以根據需求擴展，如加入 Entry 輸入框或 Scrollbar 捲軸來提升體驗。

你想在這個範例中加入更多功能嗎？ 🚀

Tkinter Python GUI（圖形使用者介面）

Tkinter 是 Python 的標準 GUI（圖形使用者介面）工具包，適用於開發桌面應用程式。它內建於 Python，無需額外安裝，可以用來建立視窗、按鈕、標籤、文字框等 UI 元件。

Tkinter 基本應用

下面是一個基本的 Tkinter 應用程式，它會顯示一個簡單的視窗，包含一個按鈕，點擊後會顯示「Hello, Tkinter!」：

import tkinter as tk
from tkinter import messagebox

def show_message():
    messagebox.showinfo("訊息", "Hello, Tkinter!")

# 創建主視窗
root = tk.Tk()
root.title("Tkinter 範例")
root.geometry("300x200")

# 新增標籤
label = tk.Label(root, text="歡迎使用 Tkinter!", font=("Arial", 14))
label.pack(pady=10)

# 新增按鈕
button = tk.Button(root, text="點我", command=show_message)
button.pack(pady=10)

# 運行主視窗
root.mainloop()

Tkinter 主要元件

元件	描述
`Label`	顯示文字或圖片
`Button`	按鈕
`Entry`	單行文字輸入框
`Text`	多行文字輸入框
`Frame`	容器元件，用於組織其他元件
`Checkbutton`	勾選框
`Radiobutton`	單選按鈕
`Listbox`	清單框
`Canvas`	畫布，可用於繪圖
`Menu`	選單欄

Tkinter 進階應用

1️⃣ 建立多行文字輸入框

import tkinter as tk

root = tk.Tk()
root.title("多行文字輸入框")

text = tk.Text(root, height=5, width=40)
text.pack()

root.mainloop()

2️⃣ 使用 `grid()` 進行佈局

Tkinter 提供 pack()、grid() 和 place() 來排列 UI 元件。

import tkinter as tk

root = tk.Tk()
root.title("Grid 佈局")

# 使用 grid() 來排列元件
tk.Label(root, text="姓名:").grid(row=0, column=0)
entry_name = tk.Entry(root)
entry_name.grid(row=0, column=1)

tk.Label(root, text="密碼:").grid(row=1, column=0)
entry_password = tk.Entry(root, show="*")
entry_password.grid(row=1, column=1)

tk.Button(root, text="登入").grid(row=2, column=0, columnspan=2)

root.mainloop()

3️⃣ 開啟新視窗

import tkinter as tk

def open_window():
    new_window = tk.Toplevel(root)
    new_window.title("新視窗")
    tk.Label(new_window, text="這是新的視窗").pack()

root = tk.Tk()
root.title("主視窗")

tk.Button(root, text="開啟新視窗", command=open_window).pack()

root.mainloop()

4️⃣ 使用 `Canvas` 繪圖

import tkinter as tk

root = tk.Tk()
root.title("Canvas 畫布")

canvas = tk.Canvas(root, width=300, height=200, bg="white")
canvas.pack()

# 畫一條線
canvas.create_line(50, 50, 250, 150, fill="red", width=3)

# 畫一個矩形
canvas.create_rectangle(50, 50, 150, 150, outline="blue", width=2)

# 畫一個圓形（橢圓）
canvas.create_oval(180, 50, 250, 120, outline="green", width=2)

root.mainloop()

這些是 Tkinter 的基礎應用，你可以根據需求來擴展功能，例如搭配 threading 來處理多線程操作，或整合 sqlite3 來存取資料庫。

你想實作哪種類型的 Tkinter 專案？ 🚀

2025年3月6日星期四

Python 18 小時課程目錄

這是 Python 18 小時課程 的整理版目錄，並附上各章節的連結，方便快速查閱：

📌 Python 18 小時

時數	主題	課程連結
第 1 小時	Python 基礎語法	🔗 連結
第 2 小時	條件判斷 (`if-elif-else`)	🔗 連結
第 3 小時	迴圈 (`for`, `while`)	🔗 連結
第 4 小時	函式與模組 (`Functions & Modules`)	🔗 連結
第 5 小時	資料結構（列表、字典、集合、元組）	🔗 連結
第 6 小時	物件導向程式設計（OOP）	🔗 連結
第 7 小時	檔案處理與錯誤處理	🔗 連結
第 8 小時	網路爬蟲（Web Scraping）	🔗 連結
第 9 小時	資料分析（Data Analysis）	🔗 連結
第 10 小時	Python 自動化應用（Excel & VBA）	🔗 連結
第 11 小時	Python 進階應用（多執行緒與網路應用）	🔗 連結
第 12 小時	Python 機器學習入門（Machine Learning）	🔗 連結
第 13 小時	Python 深度學習（Deep Learning）	🔗 連結
第 14 小時	Python 人工智慧應用（AI + Chatbot）	🔗 連結
第 15 小時	Python 與資料庫（Database Management）	🔗 連結
第 16 小時	Python 部署與雲端應用（Deployment & Cloud Computing）	🔗 連結
第 17 小時	Python 資安與測試（Security & Testing）	🔗 連結
第 18 小時	Python 自動化與爬蟲進階	🔗 連結

🎯 這份課程適合

初學者：希望快速掌握 Python 基礎
進階學習者：希望學習機器學習、AI、雲端應用
職場應用：使用 Python 進行自動化、數據處理、爬蟲

💡 透過這 18 小時的學習，快速掌握 Python，提升你的技能！🚀

Python 18 小時入門--第 4 小時：函式與模組（Functions & Modules）

📌 第 4 小時：函式與模組（Functions & Modules）

在程式設計中，函式（Function） 是可重複使用的程式碼片段，可提高程式的結構性與可讀性。Python 提供兩種函式：

內建函式（Built-in Functions）：如 print(), len(), max(), min()
自訂函式（User-defined Functions）：使用 def 定義函式

此外，Python 允許將函式放入 模組（Module），這樣我們可以在不同的程式中重複使用相同的功能。

🔹 什麼是函式？為何使用函式？

函式（Function） 是 封裝一組指令，當我們需要執行這些指令時，只要「呼叫函式」即可，不用重複撰寫相同的程式碼。

🟢 沒有函式的寫法（重複程式碼，不易維護）

print("Hello, Alice!")
print("Hello, Bob!")
print("Hello, Charlie!")

🟢 使用函式的寫法（程式碼更簡潔）

def greet(name):
    print(f"Hello, {name}!")

greet("Alice")
greet("Bob")
greet("Charlie")

📌 優點

減少重複程式碼（DRY 原則）
提高可讀性與可維護性
方便重複使用

🔹 定義與呼叫函式

Python 使用 def 關鍵字來定義函式：

def 函式名稱(參數1, 參數2, ...):
    # 函式內的程式碼
    return 回傳值

🟢 基本範例

def add(a, b):
    return a + b

result = add(3, 5)
print(result)  # 8

📌 函式的組成

函式名稱（Function Name）：add
參數（Parameters）：a, b（可選）
回傳值（Return Value）：使用 return 回傳結果（可選）

🟢 沒有回傳值的函式

如果函式內沒有 return，則會回傳 None：

def say_hello():
    print("Hello!")

result = say_hello()
print(result)  # None

🔹 函式參數

Python 支援不同類型的函式參數：

預設參數（Default Parameter）
不定參數（Arbitrary Arguments）

🟢 預設參數

def greet(name="Guest"):
    print(f"Hello, {name}!")

greet()  # Hello, Guest!
greet("Alice")  # Hello, Alice!

📌 若沒有提供參數，則使用預設值 "Guest"。

**🟢 不定參數（`*args`）**

當參數數量不固定時，可以使用 *args：

def add_all(*numbers):
    return sum(numbers)

print(add_all(1, 2, 3, 4, 5))  # 15

📌 *args 代表可變數量的參數，會以「元組（Tuple）」的形式接收。

🔹 匿名函式（Lambda Function）

Python 提供 lambda 函式（匿名函式）來簡化短小的函式，語法如下：

lambda 參數1, 參數2, ...: 表達式

🟢 範例

add = lambda a, b: a + b
print(add(3, 5))  # 8

📌 適用場景

簡單的數學運算
排序時作為 key 參數
與 map(), filter(), reduce() 搭配使用

🔹 內建函式（Built-in Functions）

Python 提供許多 內建函式，可以直接使用：

函式	說明	範例
`abs(x)`	取絕對值	`abs(-5) → 5`
`max(x, y, ...)`	取最大值	`max(1, 5, 3) → 5`
`min(x, y, ...)`	取最小值	`min(1, 5, 3) → 1`
`len(x)`	取得長度	`len("hello") → 5`
`round(x, n)`	四捨五入	`round(3.14159, 2) → 3.14`

範例：

print(max(10, 20, 30))  # 30
print(len("Python"))  # 6

🔹 模組（Module）

模組（Module）是包含 Python 函式與變數的檔案，讓我們可以在不同的程式中重複使用這些功能。

🟢 引入 Python 內建模組

import math

print(math.sqrt(25))  # 5.0
print(math.pi)  # 3.141592653589793

📌 Python 內建模組

math：數學運算
random：隨機數
datetime：日期時間處理
os：檔案與系統操作
sys：系統參數

🟢 自訂模組

我們也可以自己建立模組，然後在另一個 Python 檔案中引入。

步驟 1：建立 `mymodule.py`

def greet(name):
    print(f"Hello, {name}!")

步驟 2：在主程式引入

import mymodule

mymodule.greet("Alice")  # Hello, Alice!

📌 模組的優點

提高程式的模組化（每個模組負責不同功能）
方便重複使用
減少程式碼長度

📌 第 4 小時小結

✅ 函式（Function）可以封裝重複的程式碼，提高可讀性與維護性
✅ 函式的基本語法：def 名稱(參數): return 回傳值
✅ 參數可以有預設值，也可以使用 *args 處理不定數量參數
✅ 匿名函式（Lambda）適用於簡短的計算或排序
✅ Python 內建許多函式，如 max(), len(), round()
✅ 模組（Module）允許我們將函式封裝到外部檔案，提升程式的模組化與重複使用性

至此，你已經掌握了 Python 函式與模組，接下來我們將進入 資料結構（列表、字典、集合、元組），讓你能更有效地處理數據！🚀

Python 18 小時課程簡介

📌 Python 18 小時課程簡介

本系列課程涵蓋 Python 基礎語法、資料處理、網路爬蟲、機器學習、自動化、雲端部署 等內容，讓你從零到進階，全方位掌握 Python 技術。

📌 Python 快速入門（基礎篇）

時數	主題	內容概要
第 1 小時	Python 基礎語法	變數、數據類型、運算符、輸入輸出 (`input()` & `print()`)
第 2 小時	條件判斷 (`if-elif-else`)	條件判斷、邏輯運算、縮排規則
第 3 小時	迴圈 (`for`, `while`)	迴圈控制、`break` & `continue`、`range()`
第 4 小時	函式與模組	`def` 定義函式、參數與回傳值、模組導入 (`import`)
第 5 小時	資料結構（列表、字典、集合、元組）	內建數據結構、增刪改查、排序與操作

📌 Python 進階（物件導向 & 檔案處理）

時數	主題	內容概要
第 6 小時	物件導向程式設計（OOP）	類別 (`class`)、物件 (`object`)、繼承 (`inheritance`)
第 7 小時	檔案處理與錯誤處理	`open()` 讀寫檔案、`try-except` 例外處理
第 8 小時	網路爬蟲入門	`requests` 爬取網頁、`BeautifulSoup` 解析 HTML
第 9 小時	資料分析（pandas & NumPy）	`pandas` 數據處理、`NumPy` 陣列運算、數據視覺化 (`Matplotlib`)

📌 Python 進階應用（機器學習 & AI）

時數	主題	內容概要
第 10 小時	自動化應用（Excel & VBA）	`openpyxl` 操作 Excel、`pyautogui` 自動鍵鼠控制
第 11 小時	多執行緒與網路應用	`threading` 多工處理、`socket` 網路通訊、`Flask` Web API
第 12 小時	機器學習入門 (`scikit-learn`)	監督式學習（分類 & 回歸）、數據預處理 (`train_test_split()`)
第 13 小時	深度學習（TensorFlow & Keras）	人工神經網路 (`ANN`)、卷積神經網路 (`CNN`)

📌 Python 高階應用（AI、資料庫、雲端部署）

時數	主題	內容概要
第 14 小時	人工智慧應用（Chatbot）	`NLTK` 自然語言處理 (`NLP`)、整合 ChatGPT API
第 15 小時	Python 與資料庫	`sqlite3` 操作 SQLite、`MySQL`、`MongoDB`
第 16 小時	部署與雲端應用	`Flask` + `Gunicorn` 部署、Docker 容器化、AWS EC2 部署
第 17 小時	資安與測試	SQL Injection 防禦、`bcrypt` 密碼加密、`pytest` 單元測試
第 18 小時	自動化與爬蟲進階	`Selenium` 爬取 JavaScript、定時任務 (`schedule`)、批量 Excel 處理

🎯 適合對象

新手學 Python，希望在短時間內掌握核心概念
有程式基礎但想進階，學習資料處理、機器學習、雲端部署
想提升職場競爭力，使用 Python 自動化 Excel、API、AI 專案

這份 18 小時學習計劃，讓你從基礎到進階，全面掌握 Python 的核心技術！🚀

Python 18 小時入門--第 18 小時：Python 自動化與爬蟲進階應用（Advanced Automation & Web Scraping）

📌 第 18 小時：Python 自動化與爬蟲進階應用（Advanced Automation & Web Scraping）

Python 不僅可以用來寫應用程式，還能用來 自動化重複性工作，如：

網路爬蟲（Scraping）
批量下載與資料擷取
定時執行任務（Scheduling）
批次處理檔案

本章將介紹：

使用 requests 爬取動態數據
使用 Selenium 爬取 JavaScript 生成的數據
批量下載圖片與檔案
定時執行任務（使用 schedule）
批量處理 Excel 檔案

🔹 1. 使用 `requests` 爬取動態數據

requests 可用來抓取 JSON API 或靜態網頁。

🟢 下載 JSON API

import requests

url = "https://jsonplaceholder.typicode.com/posts/1"
response = requests.get(url)

data = response.json()
print(data)

📌 適用於 API 服務，回傳 JSON 格式的數據。

🟢 爬取網頁 HTML

from bs4 import BeautifulSoup

url = "https://example.com"
response = requests.get(url)

soup = BeautifulSoup(response.text, "html.parser")
print(soup.title.text)  # 取得標題

📌 適用於靜態 HTML 爬取，如新聞標題、商品資訊。

🔹 2. 使用 `Selenium` 爬取 JavaScript 生成的數據

有些網站的數據 由 JavaScript 動態加載，requests 無法直接爬取，需使用 Selenium。

🟢 安裝 `Selenium`

pip install selenium

並下載 ChromeDriver：點此下載

🟢 自動開啟瀏覽器

from selenium import webdriver

driver = webdriver.Chrome()
driver.get("https://www.python.org")

print(driver.title)  # 取得網頁標題
driver.quit()

📌 Selenium 可讓 Python 自動操作瀏覽器，適合爬取需要登入的網站。

🟢 自動填寫表單

from selenium.webdriver.common.by import By
from selenium.webdriver.common.keys import Keys

driver = webdriver.Chrome()
driver.get("https://www.google.com")

search_box = driver.find_element(By.NAME, "q")
search_box.send_keys("Python 自動化", Keys.RETURN)  # 輸入並按 Enter

driver.quit()

📌 適用於模擬登入、查詢資料、批量輸入數據。

🔹 3. 批量下載圖片與檔案

requests 可用於自動下載圖片或檔案。

🟢 批量下載圖片

import os

url = "https://www.example.com/image.jpg"
response = requests.get(url)

with open("image.jpg", "wb") as file:
    file.write(response.content)

print("下載完成！")

📌 適用於爬取網路圖片，如表情包、壁紙等。

🔹 4. 定時執行任務（使用 `schedule`）

有時我們希望 每隔一段時間自動執行某個任務（如自動備份）。

🟢 安裝 `schedule`

pip install schedule

🟢 每 10 秒執行一次任務

import schedule
import time

def job():
    print("執行自動化任務...")

schedule.every(10).seconds.do(job)

while True:
    schedule.run_pending()
    time.sleep(1)

📌 適用於定時發送 Email、爬蟲、定期報告等。

🔹 5. 批量處理 Excel 檔案

我們可以使用 pandas 自動處理 Excel 合併多個檔案 或 格式轉換。

🟢 合併多個 Excel

import pandas as pd
import os

files = ["data1.xlsx", "data2.xlsx"]
dfs = [pd.read_excel(f) for f in files]

merged_df = pd.concat(dfs)  # 合併
merged_df.to_excel("merged.xlsx", index=False)

📌 適用於處理財務報表、考試成績、自動整理 Excel 數據。

📌 第 18 小時小結

✅ 使用 requests 進行網頁爬取，獲取 JSON 或 HTML
✅ 使用 Selenium 爬取 JavaScript 生成的內容，可模擬瀏覽器操作
✅ 批量下載圖片或檔案，自動化整理數據
✅ 使用 schedule 設定定時任務，每隔一定時間執行腳本
✅ 批量處理 Excel 檔案，如合併報表、格式轉換

學完這一章，你已掌握 Python 進階自動化與爬蟲技術，現在可以利用 Python 自動處理重複性工作，提升工作效率！🚀

Python 18 小時入門--第 17 小時：Python 資安與測試（Security & Testing）

📌 第 17 小時：Python 資安與測試（Security & Testing）

開發 Python 應用程式時，安全性與測試至關重要。本章將介紹：

Python 應用的安全風險
防範 SQL Injection（SQL 注入攻擊）
密碼雜湊與加密
使用 unittest 進行單元測試
使用 pytest 進行自動化測試
API 測試與 Postman

🔹 1. Python 應用的安全風險

開發 Web 應用與 API 時，常見的安全風險包括：

攻擊類型	說明	解決方案
SQL Injection（SQL 注入）	透過惡意 SQL 操作資料庫	使用參數化查詢
XSS（跨站腳本攻擊）	在網頁中插入惡意 JavaScript	避免直接輸出未經處理的用戶輸入
CSRF（跨站請求偽造）	利用受信任用戶發送惡意請求	使用 CSRF Token
弱密碼	使用簡單密碼容易被破解	使用密碼雜湊（bcrypt, SHA256）

📌 防禦策略

永遠不要信任用戶輸入
使用加密技術保護密碼
定期更新套件，修補安全漏洞

🔹 2. 防範 SQL Injection（SQL 注入攻擊）

惡意攻擊者可能會輸入 ' OR 1=1 -- 這類字串來繞過驗證，獲取未授權的數據。

🟢 危險範例（SQL Injection）

import sqlite3

conn = sqlite3.connect("example.db")
cursor = conn.cursor()

username = input("輸入用戶名: ")  # 用戶輸入 ' OR 1=1 --
query = f"SELECT * FROM users WHERE username = '{username}'"

cursor.execute(query)  # ⚠️ 這樣會讓駭客獲取所有數據

🟢 安全做法：使用參數化查詢

cursor.execute("SELECT * FROM users WHERE username = ?", (username,))

📌 這樣的查詢不會被惡意 SQL 語法影響。

🔹 3. 密碼雜湊與加密

存儲用戶密碼時，應該使用雜湊算法加密，而不是明文存放。

🟢 使用 `bcrypt` 進行密碼加密

pip install bcrypt

import bcrypt

# 生成密碼雜湊
password = "mypassword"
hashed = bcrypt.hashpw(password.encode(), bcrypt.gensalt())

print(hashed)  # 儲存這個雜湊到資料庫

🟢 驗證密碼

if bcrypt.checkpw("mypassword".encode(), hashed):
    print("密碼正確")
else:
    print("密碼錯誤")

📌 即使駭客獲取了密碼雜湊，也無法輕易破解。

🔹 4. 使用 `unittest` 進行單元測試

測試可以確保程式的正確性，unittest 是 Python 內建的測試框架。

🟢 建立測試

import unittest

def add(x, y):
    return x + y

class TestMath(unittest.TestCase):
    def test_add(self):
        self.assertEqual(add(2, 3), 5)
        self.assertEqual(add(-1, 1), 0)

if __name__ == "__main__":
    unittest.main()

📌 這會自動測試 add(2, 3) 是否等於 5。

🔹 5. 使用 `pytest` 進行自動化測試

pytest 比 unittest 更簡潔，適合大規模測試。

🟢 安裝 `pytest`

pip install pytest

🟢 撰寫 `test_math.py`

def add(x, y):
    return x + y

def test_add():
    assert add(2, 3) == 5
    assert add(-1, 1) == 0

🟢 執行測試

pytest

📌 pytest 會自動執行 test_ 開頭的函式。

🔹 6. API 測試與 `Postman`

開發 API 時，可以使用 Postman 進行測試：Postman 官方網站

🟢 Flask API 測試

from flask import Flask, jsonify

app = Flask(__name__)

@app.route("/api")
def api():
    return jsonify({"message": "Hello, API!"})

if __name__ == "__main__":
    app.run(debug=True)

📌 啟動後，可用 Postman 測試 http://127.0.0.1:5000/api。

📌 第 17 小時小結

✅ 防止 SQL Injection，使用參數化查詢
✅ 密碼應使用 bcrypt 雜湊存儲，避免明文存放
✅ unittest & pytest 可用於自動化測試，確保程式正確性
✅ 使用 Postman 測試 API，確保 Web 服務運作正常

學完這一章，你已掌握 Python 應用的安全性與測試方法，下一步將學習 Python 自動化與爬蟲進階應用！🚀

Python 18 小時入門--第 16 小時：Python 部署與雲端應用（Deployment & Cloud Computing）

📌 第 16 小時：Python 部署與雲端應用（Deployment & Cloud Computing）

學完 Python 基礎後，將程式部署到雲端是重要的一步。本章將介紹：

Python 應用程式的部署方式
使用 Flask + Gunicorn 部署 Web 應用
Docker 容器化應用
部屬到 AWS（Amazon Web Services）
使用 GitHub Actions 進行 CI/CD（自動化部署）

🔹 1. Python 應用部署方式

Python 應用的部署方式有：

方式	適用場景	優勢
本地運行	測試、小型應用	方便開發，但無法遠端存取
伺服器部署（Flask + Gunicorn）	Web 應用、API	適合一般後端應用
Docker 容器化	雲端部署、微服務	環境獨立，適合 CI/CD
雲端平台（AWS, Google Cloud, Heroku）	大規模應用	可自動擴展，適合商業應用

🔹 2. Flask + Gunicorn 部署 Web 應用

Flask 是 Python 的輕量級 Web 框架，可用於開發 API 或網站。

🟢 安裝 Flask

pip install flask gunicorn

🟢 建立 `app.py`

from flask import Flask

app = Flask(__name__)

@app.route("/")
def home():
    return "歡迎來到 Python 部署測試！"

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=5000)

📌 這是最簡單的 Flask 伺服器，啟動後可透過 http://127.0.0.1:5000/ 訪問。

🟢 使用 `Gunicorn` 運行

Gunicorn 是 生產環境（Production） 用來部署 Flask 的 WSGI 伺服器：

gunicorn -w 4 -b 0.0.0.0:5000 app:app

📌 這會啟動 4 個 Worker 處理請求，提高效能。

🔹 3. Docker 容器化應用

Docker 可以將 Python 應用打包成容器，方便跨平台部署。

🟢 安裝 Docker

官方下載

🟢 建立 `Dockerfile`

# 使用 Python 官方映像檔
FROM python:3.10

# 設定工作目錄
WORKDIR /app

# 複製程式碼到容器內
COPY . .

# 安裝 Flask
RUN pip install flask gunicorn

# 執行 Flask 伺服器
CMD ["gunicorn", "-w", "4", "-b", "0.0.0.0:5000", "app:app"]

🟢 建立 Docker 容器

docker build -t my-python-app .

🟢 運行 Docker 容器

docker run -p 5000:5000 my-python-app

📌 這樣 Python Web 應用就可以在 Docker 容器內運行！

🔹 4. 部署到 AWS（Amazon Web Services）

AWS 是最受歡迎的雲端平台，這裡示範 部署 Flask 到 AWS EC2。

🟢 步驟

註冊 AWS 帳戶：AWS 官網
啟動 EC2 伺服器
- 選擇 Ubuntu 伺服器
- 設定 允許 HTTP 及 SSH 存取
透過 SSH 連接伺服器
```
ssh -i your-key.pem ubuntu@your-ec2-ip
```

安裝 Python 與 Flask

sudo apt update
sudo apt install python3-pip
pip3 install flask gunicorn

啟動 Flask 應用
```
gunicorn -w 4 -b 0.0.0.0:5000 app:app
```
設定防火牆開放 5000 端口
```
sudo ufw allow 5000
```

📌 訪問 http://your-ec2-ip:5000/，即完成 AWS 部署！

🔹 5. 使用 GitHub Actions 進行 CI/CD

CI/CD（持續整合與持續部署）可以讓 Python 應用自動化部署。

🟢 建立 GitHub Actions

在 GitHub 專案根目錄 建立 .github/workflows/deploy.yml：

name: Deploy Python App

on:
  push:
    branches:
      - main  # 當 main 分支有新 commit 時執行

jobs:
  deploy:
    runs-on: ubuntu-latest

    steps:
    - name: 取得程式碼
      uses: actions/checkout@v2

    - name: 設定 Python 環境
      uses: actions/setup-python@v2
      with:
        python-version: '3.10'

    - name: 安裝依賴
      run: pip install flask gunicorn

    - name: 部署應用（假設使用 SSH）
      run: |
        ssh -i ${{ secrets.SSH_KEY }} ubuntu@your-ec2-ip "cd /app && git pull && systemctl restart flask"

📌 當你 Push 程式碼到 main 分支時，GitHub Actions 會自動部署到 AWS 伺服器。

📌 第 16 小時小結

✅ Flask 可用於開發 Python Web 應用，Gunicorn 可在生產環境運行
✅ Docker 可以將 Python 應用容器化，方便部署
✅ AWS EC2 可用於部署 Flask 應用
✅ GitHub Actions 可用於 CI/CD 自動化部署

學完這一章，你已掌握 Python 應用部署與雲端技術，下一步將學習 Python 的資安與測試，確保應用安全性！🚀

Python 18 小時入門--第 15 小時：Python 與資料庫（Database Management）

📌 第 15 小時：Python 與資料庫（Database Management）

Python 可用於資料庫管理，讓我們能夠儲存、查詢、更新和刪除大量數據。本章將介紹：

SQL vs NoSQL 資料庫
使用 sqlite3 操作 SQLite
使用 MySQL 進行資料管理
使用 MongoDB 儲存 NoSQL 資料
SQLAlchemy 進行 ORM（物件關聯映射）

🔹 1. SQL vs NoSQL 資料庫

類型	說明	例子
SQL（關聯式資料庫）	結構化數據，使用表格儲存	MySQL, PostgreSQL, SQLite
NoSQL（非關聯式資料庫）	適用於非結構化數據（JSON、文件）	MongoDB, Firebase, Redis

📌 SQL 適合結構化數據（如使用者資料），NoSQL 適合非結構化數據（如聊天記錄）。

🔹 2. 使用 `sqlite3` 操作 SQLite

SQLite 是輕量級的 SQL 資料庫，適合小型應用程式，內建於 Python 無需額外安裝。

🟢 建立 SQLite 資料庫

import sqlite3

# 連接 SQLite（若檔案不存在會自動建立）
conn = sqlite3.connect("example.db")
cursor = conn.cursor()

# 建立表格
cursor.execute('''
    CREATE TABLE IF NOT EXISTS users (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        name TEXT,
        age INTEGER
    )
''')

conn.commit()
conn.close()

🟢 插入數據

conn = sqlite3.connect("example.db")
cursor = conn.cursor()

cursor.execute("INSERT INTO users (name, age) VALUES (?, ?)", ("Alice", 25))
cursor.execute("INSERT INTO users (name, age) VALUES (?, ?)", ("Bob", 30))

conn.commit()
conn.close()

🟢 查詢數據

conn = sqlite3.connect("example.db")
cursor = conn.cursor()

cursor.execute("SELECT * FROM users")
rows = cursor.fetchall()

for row in rows:
    print(row)

conn.close()

📌 結果

(1, 'Alice', 25)
(2, 'Bob', 30)

🟢 更新與刪除數據

cursor.execute("UPDATE users SET age = ? WHERE name = ?", (26, "Alice"))
cursor.execute("DELETE FROM users WHERE name = ?", ("Bob",))

🔹 3. 使用 `MySQL` 操作大型資料庫

MySQL 是常見的關聯式資料庫，適合中大型應用，如 網站後端、電子商務系統。

🟢 安裝 `MySQL Connector`

pip install mysql-connector-python

🟢 連接 MySQL

import mysql.connector

conn = mysql.connector.connect(
    host="localhost",
    user="root",
    password="你的密碼",
    database="test_db"
)
cursor = conn.cursor()

🟢 創建 MySQL 資料表

cursor.execute('''
    CREATE TABLE users (
        id INT AUTO_INCREMENT PRIMARY KEY,
        name VARCHAR(100),
        age INT
    )
''')

🟢 插入數據

cursor.execute("INSERT INTO users (name, age) VALUES (%s, %s)", ("Charlie", 28))
conn.commit()

🟢 查詢數據

cursor.execute("SELECT * FROM users")
rows = cursor.fetchall()
for row in rows:
    print(row)

🔹 4. 使用 `MongoDB`（NoSQL 資料庫）

MongoDB 是 NoSQL 資料庫，適合 儲存 JSON 格式的大量數據。

🟢 安裝 `pymongo`

pip install pymongo

🟢 連接 MongoDB

from pymongo import MongoClient

client = MongoClient("mongodb://localhost:27017/")
db = client["mydatabase"]
collection = db["users"]

🟢 插入 JSON 數據

user = {"name": "Alice", "age": 25}
collection.insert_one(user)

🟢 查詢數據

for user in collection.find():
    print(user)

🔹 5. `SQLAlchemy` 進行 ORM

SQLAlchemy 是 ORM（物件關聯映射），允許我們用 Python 類別操作資料庫。

🟢 安裝 `SQLAlchemy`

pip install sqlalchemy

🟢 定義模型

from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker

Base = declarative_base()

class User(Base):
    __tablename__ = "users"
    id = Column(Integer, primary_key=True, autoincrement=True)
    name = Column(String(100))
    age = Column(Integer)

# 建立資料庫連線
engine = create_engine("sqlite:///example.db")
Base.metadata.create_all(engine)

Session = sessionmaker(bind=engine)
session = Session()

🟢 插入數據

user = User(name="Alice", age=25)
session.add(user)
session.commit()

🟢 查詢數據

users = session.query(User).all()
for user in users:
    print(user.name, user.age)

📌 第 15 小時小結

✅ SQL（如 MySQL、SQLite）適合結構化數據，NoSQL（如 MongoDB）適合非結構化數據
✅ 使用 sqlite3 操作 SQLite，小型應用適用
✅ 使用 MySQL 處理大量結構化數據
✅ 使用 MongoDB 儲存 JSON 格式的 NoSQL 數據
✅ 使用 SQLAlchemy 進行 ORM，讓 Python 直接操作資料庫

學完這一章，你已掌握 Python 與資料庫整合，下一步將學習 Python 部署與雲端應用，讓你的程式真正上線！🚀

Python 18 小時入門--第 14 小時：Python 人工智慧應用（AI + Chatbot）

📌 第 14 小時：Python 人工智慧應用（AI + Chatbot）

Python 在 人工智慧（AI） 方面有許多應用，包括 聊天機器人（Chatbot）、語音辨識、推薦系統 等。本章將介紹：

AI 概念與應用
使用 NLTK 進行自然語言處理
建構簡單的聊天機器人（Chatbot）
整合 OpenAI ChatGPT API
語音辨識與 TTS（Text-to-Speech）

🔹 1. AI 概念與應用

人工智慧（AI） 讓機器具備 學習、推理與決策能力，應用於：

語音助理（Siri, Google Assistant）
推薦系統（Netflix, YouTube）
聊天機器人（LineBot, ChatGPT）
電商 AI 客服

📌 AI 的三大關鍵技術

機器學習（Machine Learning）：從數據中學習模式（如房價預測）
深度學習（Deep Learning）：使用神經網路進行更複雜的學習（如影像辨識）
自然語言處理（NLP）：讓機器理解人類語言（如 Chatbot）

🔹 2. 使用 `NLTK` 進行 NLP

Python 的 NLTK（Natural Language Toolkit） 是最常見的 NLP 庫。

🟢 安裝 `NLTK`

pip install nltk

🟢 文字處理

import nltk
from nltk.tokenize import word_tokenize

nltk.download("punkt")

text = "Hello, how are you doing today?"
tokens = word_tokenize(text)

print(tokens)  # ['Hello', ',', 'how', 'are', 'you', 'doing', 'today', '?']

📌 Tokenization（分詞） 會將句子拆解成單字，方便分析。

🔹 3. 建構簡單 Chatbot

我們可以用 NLTK 建構一個簡單的聊天機器人。

🟢 安裝 `ChatterBot`

pip install chatterbot chatterbot_corpus

🟢 建立 Chatbot

from chatterbot import ChatBot
from chatterbot.trainers import ChatterBotCorpusTrainer

# 創建 Chatbot
bot = ChatBot("AI 助理")

# 訓練模型
trainer = ChatterBotCorpusTrainer(bot)
trainer.train("chatterbot.corpus.english")

# 測試聊天機器人
while True:
    user_input = input("你: ")
    response = bot.get_response(user_input)
    print("AI:", response)

📌 Chatbot 會學習內建的 chatterbot.corpus.english 資料庫，並與使用者互動。

🔹 4. 整合 OpenAI ChatGPT API

我們也可以整合 ChatGPT API 來提升 Chatbot 智能。

🟢 申請 OpenAI API

註冊 OpenAI 帳戶：https://openai.com
取得 API Key
安裝 openai 套件：
```
pip install openai
```

🟢 使用 ChatGPT API

import openai

openai.api_key = "你的 API Key"

def chat_with_gpt(prompt):
    response = openai.ChatCompletion.create(
        model="gpt-3.5-turbo",
        messages=[{"role": "user", "content": prompt}]
    )
    return response["choices"][0]["message"]["content"]

while True:
    user_input = input("你: ")
    reply = chat_with_gpt(user_input)
    print("ChatGPT:", reply)

📌 這段程式碼會與 OpenAI ChatGPT 互動，並回應使用者輸入的內容！

🔹 5. 語音辨識與 TTS（Text-to-Speech）

🟢 安裝 `SpeechRecognition` & `pyttsx3`

pip install SpeechRecognition pyttsx3

🟢 語音轉文字

import speech_recognition as sr

recognizer = sr.Recognizer()

with sr.Microphone() as source:
    print("請說話...")
    audio = recognizer.listen(source)
    
    try:
        text = recognizer.recognize_google(audio, language="zh-TW")
        print(f"你說的是: {text}")
    except sr.UnknownValueError:
        print("無法辨識語音")

📌 這段程式碼會啟動麥克風，將語音轉為文字。

🟢 文字轉語音

import pyttsx3

engine = pyttsx3.init()
engine.say("你好，我是 AI 助理")
engine.runAndWait()

📌 這段程式碼會讓電腦朗讀 "你好，我是 AI 助理"。

📌 第 14 小時小結

✅ 人工智慧應用於 Chatbot、語音助理、推薦系統等
✅ NLTK 可用於自然語言處理（NLP），如文字分詞
✅ ChatterBot 可建立基礎聊天機器人
✅ 整合 OpenAI ChatGPT API 讓 Chatbot 變得更聰明
✅ SpeechRecognition 用於語音辨識，pyttsx3 可讓電腦朗讀文字

學完這一章，你已掌握 AI 應用與 Chatbot 互動，下一步將學習 Python + 資料庫，如何管理與存取大量數據！🚀

Python 18 小時入門--第 13 小時：Python 深度學習入門（Deep Learning with TensorFlow & Keras）

📌 第 13 小時：Python 深度學習入門（Deep Learning with TensorFlow & Keras）

深度學習（Deep Learning）是機器學習的進階技術，使用人工神經網路（Artificial Neural Networks, ANN） 模擬人腦的學習方式。Python 提供 TensorFlow 和 Keras 來構建強大的深度學習模型。本章將介紹：

深度學習概念
安裝 TensorFlow & Keras
建立神經網路（ANN）
訓練影像分類模型（CNN）
自然語言處理（NLP）
模型評估與改進

🔹 1. 深度學習概念

深度學習基於 人工神經網路（ANN），模擬大腦神經元的工作方式，主要用於：

影像辨識（CNN）：人臉識別、醫學影像分析
自然語言處理（NLP）：聊天機器人、語音辨識、翻譯
強化學習（Reinforcement Learning）：自駕車、遊戲 AI

🔹 神經網路的基本結構

輸入層（Input Layer）：負責接收數據
隱藏層（Hidden Layers）：透過 神經元（Neurons） 進行特徵學習
輸出層（Output Layer）：產生預測結果

📌 深度學習的關鍵技術：

激活函數（Activation Function）：如 ReLU、Sigmoid、Softmax
損失函數（Loss Function）：衡量模型錯誤程度
優化器（Optimizer）：如 SGD、Adam，負責模型學習

🔹 2. 安裝 TensorFlow & Keras

TensorFlow 是 Google 開發的深度學習框架，Keras 是其高階 API，可快速建立神經網路。

🟢 安裝 TensorFlow

pip install tensorflow

🟢 檢查 TensorFlow 是否成功安裝

import tensorflow as tf
print(tf.__version__)  # 檢查 TensorFlow 版本

🔹 3. 建立簡單的神經網路

我們將使用 Keras 建立 人工神經網路（ANN） 來預測 手寫數字辨識（MNIST）。

🟢 讀取數據

from tensorflow.keras.datasets import mnist
from tensorflow.keras.utils import to_categorical

# 下載 MNIST 手寫數字資料集
(X_train, y_train), (X_test, y_test) = mnist.load_data()

# 正規化數據（0~255 → 0~1）
X_train, X_test = X_train / 255.0, X_test / 255.0

# One-hot 編碼
y_train = to_categorical(y_train, 10)
y_test = to_categorical(y_test, 10)

🟢 建立 ANN 模型

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Flatten

model = Sequential([
    Flatten(input_shape=(28, 28)),  # 轉換 28x28 圖片為 1D 向量
    Dense(128, activation="relu"),  # 隱藏層
    Dense(10, activation="softmax")  # 輸出層（10 類別）
])

model.compile(optimizer="adam", loss="categorical_crossentropy", metrics=["accuracy"])
model.summary()  # 顯示模型架構

🟢 訓練模型

model.fit(X_train, y_train, epochs=10, validation_data=(X_test, y_test))

📌 每個 epoch 表示模型掃描完整數據集一次，訓練 10 次。

🔹 4. 訓練卷積神經網路（CNN）

卷積神經網路（Convolutional Neural Network, CNN）專門用於 影像辨識，我們來建立 CNN 來辨識手寫數字。

🟢 建立 CNN 模型

from tensorflow.keras.layers import Conv2D, MaxPooling2D

model = Sequential([
    Conv2D(32, (3,3), activation="relu", input_shape=(28,28,1)),  # 卷積層
    MaxPooling2D((2,2)),  # 池化層
    Flatten(),
    Dense(128, activation="relu"),
    Dense(10, activation="softmax")
])

model.compile(optimizer="adam", loss="categorical_crossentropy", metrics=["accuracy"])
model.fit(X_train.reshape(-1,28,28,1), y_train, epochs=10, validation_data=(X_test.reshape(-1,28,28,1), y_test))

📌 CNN 由 卷積層（Conv2D）+ 池化層（MaxPooling2D）+ 全連接層（Dense） 組成，可擷取影像特徵。

🔹 5. 自然語言處理（NLP）

NLP 主要處理 文字數據，如 情感分析、機器翻譯、聊天機器人。

🟢 使用 `TensorFlow` 進行 NLP

from tensorflow.keras.preprocessing.text import Tokenizer

texts = ["I love Python", "Deep Learning is amazing", "NLP is fun"]
tokenizer = Tokenizer(num_words=1000)
tokenizer.fit_on_texts(texts)

word_index = tokenizer.word_index
print(word_index)  # 顯示單字索引

📌 Tokenizer 可將文字轉換為數字序列，便於神經網路訓練。

🔹 6. 模型評估與調整

🟢 模型評估

loss, accuracy = model.evaluate(X_test.reshape(-1,28,28,1), y_test)
print(f"測試集準確率: {accuracy:.2f}")

🟢 避免過擬合（Overfitting）

過擬合（Overfitting）是指模型在訓練集表現很好，但測試集效果差，解決方法：

加入 Dropout 層：隨機忽略部分神經元，增加模型泛化能力

from tensorflow.keras.layers import Dropout

model.add(Dropout(0.5))  # 50% 隨機忽略

增加數據增強（Data Augmentation）

from tensorflow.keras.preprocessing.image import ImageDataGenerator

datagen = ImageDataGenerator(rotation_range=10, zoom_range=0.1)
datagen.fit(X_train.reshape(-1,28,28,1))

📌 第 13 小時小結

✅ 深度學習基於人工神經網路（ANN）與卷積神經網路（CNN）
✅ TensorFlow 和 Keras 提供高效的深度學習框架
✅ Sequential() 建立神經網路，Dense() 定義神經元層
✅ model.fit() 訓練模型，model.evaluate() 測試模型
✅ Conv2D() 卷積層專門用於影像辨識
✅ 避免過擬合的方法：Dropout、Data Augmentation

學完這一章，你已掌握 深度學習基礎與 Python 實作，下一步將學習 人工智慧應用（AI + Chatbot），讓你的 Python 能與人類對話！🚀

訂閱：文章 (Atom)

2025年3月27日 星期四

2025年3月11日 星期二

2025年3月10日 星期一

2025年3月7日 星期五

Python 讀寫 SQLite（Docker 最簡單範例）

1. 建立專案目錄

2. 建立 Python 讀寫 SQLite 檔案

3. 建立 Dockerfile

4. 建立 Docker 映像檔

5. 運行 Docker 容器

6. 檢查 SQLite 資料庫

7. 停止 & 刪除容器

🚀 總結

Flask 留言板（留言存入檔案 + Docker 版本）

1. 建立 Flask 留言板

1.1 建立 app.py

這個 Flask 應用做了什麼？

1.2 建立 templates/index.html

2. 建立 Dockerfile

3. 建立 Docker 映像檔

4. 運行 Flask 容器

5. 訪問 Flask 留言板

6. 如何更新 Flask 應用？

7. 停止 & 刪除容器

簡單 Flask 留言板（Docker 版本）

1. 準備 Flask 應用

1.1 建立專案資料夾

1.2 建立 app.py

1.3 建立 templates/index.html

2. 建立 Dockerfile

3. 建立 Docker 映像檔

4. 運行 Flask 容器

5. 訪問 Flask 留言板

6. 修改 Flask 應用後，如何更新？

6.1 停止並刪除舊容器

6.2 重新建置映像

6.3 重新運行

7. 即時開發模式（Volume 掛載）

8. 停止 & 刪除容器

修改 Web 內容後，如何重新發佈？

步驟 1：修改 Web 內容

步驟 2：刪除舊容器

步驟 3：重新建置 Docker 映像檔

步驟 4：重新運行容器

快速更新的方法（開發模式）

最簡單的 Docker 網頁應用

1. 準備專案

2. 建立 Flask 應用程式

3. 建立 Dockerfile

4. 建立 Docker 映像檔

5. 運行 Docker 容器

6. 開啟網頁

7. 停止與刪除容器

8. 常用 Docker 指令

1. 安裝 Docker Desktop

1.1 下載並安裝

1.2 驗證安裝

2. 運行第一個 Docker 容器

2.1 拉取 Python 映像檔

2.2 運行 Python 容器

3. 建立自己的 Docker 映像檔

3.1 建立專案目錄

3.2 建立 Python 檔案

3.3 建立 Dockerfile

3.4 建立 Docker 映像檔

3.5 執行容器

4. 常見 Docker 指令（Windows）

完整 Tkinter 選單範例

功能解釋

1️⃣ 主選單 menu_bar

2️⃣ File (檔案) 選單

3️⃣ Edit (編輯) 選單

4️⃣ Help (說明) 選單

5️⃣ 鍵盤快捷鍵

額外擴展

完整 Tkinter GUI 範例

程式功能解釋

Tkinter 基本應用

Tkinter 主要元件

Tkinter 進階應用

2025年3月27日星期四

2025年3月11日星期二

2025年3月10日星期一

2025年3月7日星期五

1.1 建立 `app.py`

1.2 建立 `templates/index.html`

1.2 建立 `app.py`

1.3 建立 `templates/index.html`

1️⃣ 主選單 `menu_bar`

2️⃣ `File` (檔案) 選單

3️⃣ `Edit` (編輯) 選單

4️⃣ `Help` (說明) 選單

2️⃣ 使用 `grid()` 進行佈局

4️⃣ 使用 `Canvas` 繪圖

2025年3月6日星期四

**🟢 不定參數（`*args`）**

步驟 1：建立 `mymodule.py`

🔹 1. 使用 `requests` 爬取動態數據

🔹 2. 使用 `Selenium` 爬取 JavaScript 生成的數據

🟢 安裝 `Selenium`

🔹 4. 定時執行任務（使用 `schedule`）

🟢 安裝 `schedule`