# 高中部多元選修：程式設計
## 課程基本資訊
- **課程名稱**：(多元選修)程式設計
- **課程時長**：每週 **1 小時**
- **總週數**：**21 週**
## 課程進度安排
| 週次 | 課程內容 | 重要事件 |
|-------|---------------------|---------------------|
| 第1週 | 程式設計概論 | |
| 第2週 | 基本語法介紹 | |
| 第3週 | 控制結構 | |
| 第4週 | 函數與模組 | |
| 第5週 | 資料結構簡介 | |
| 第6週 | 實作練習 | |
| 第7週 | **第一次報告** | 報告主題：前六週內容 |
| 第8週 | 物件導向程式設計 | |
| 第9週 | 例外處理與調試 | |
| 第10週| 資料庫基礎 | |
| 第11週| 網頁程式設計基礎 | |
| 第12週| 實作練習 | |
| 第13週| 專題討論 | |
| 第14週| **第二次報告** | 報告主題：第8-13週內容 |
| 第15週| 資料分析簡介 | |
| 第16週| 前端與後端技術 | |
| 第17週| 專題實作 | |
| 第18週| 課程回顧 | |
| 第19週| 期末考試準備 | |
| 第20週| 期末考試 | |
| 第21週| **期末報告** | 報告主題：整體課程總結 |
## 重要報告
- **第一次報告**：第 **7 週**
- **第二次報告**：第 **14 週**
- **期末報告**：第 **21 週**
---
# 第1週：程式設計概論
## 課程目標
- 了解程式設計的基本概念
- 探索程式設計的歷史與應用
- 確立學習程式設計的動機與目標
## 課程大綱
### 1. 程式設計的定義
- **程式設計**：使用特定語言撰寫指令，讓電腦執行特定任務。
- 一種將人類邏輯轉換為電腦可理解指令的過程。
- 重要性：提升解決問題的能力，優化工作流程。
- 解決問題：透過程式設計，可以有效地解決各種問題。
- 優化流程：自動化重複性工作，提升工作效率。
### 2. 程式設計的歷史
- 早期的程式設計語言（如 Fortran, COBOL）
- Fortran：1950年代初期，主要用於科學計算。
- COBOL：同樣在1950年代，主要用於商業應用。
- 現代程式設計語言（如 Python, Java, C++）
- Python：易學易用，適合初學者和數據分析。
- Java：廣泛應用於企業級應用和Android開發。
- C++：常用於系統程式設計和高效能應用。
- 程式設計的演進與技術發展
### 3. 程式設計的應用領域
- **網頁開發**：HTML, CSS, JavaScript
- **軟體開發**：桌面應用程式與行動應用程式
- **數據分析**：數據處理與可視化
- **遊戲開發**：互動娛樂使用 Unity、Unreal Engine 等平台開發互動娛樂。
### 4. 課程架構與學習目標
- 課程內容概覽（後續週次安排）
- 每週主題簡介，涵蓋基礎語法、控制結構、數據結構等。
- 學習成果（能力評估標準）
- 能夠獨立撰寫簡單的程式，解決實際問題。
- 期望學生參與度與作業要求
### 5. 第一堂課活動
- 自我介紹與學習動機分享
- 小組討論：為什麼學習程式設計？
### 6. 課後作業
- 撰寫一篇短文，描述你對程式設計的看法及期望學習的內容。
---
# 第2週上課內容：基本語法介紹
## 課程目標
- 理解程式語言的基本語法
- 學習如何撰寫簡單的程式碼
- 培養編寫可讀性高的程式碼的能力
## 課程大綱
### 1. 程式語言概述
- 程式語言的定義：
程式語言是用來撰寫指令以控制電腦行為的工具。
- 常見程式語言：
- Python：適合初學者，功能強大。
- Java：跨平台，廣泛應用於企業和Android開發。
- JavaScript：主要用於網頁開發，增加互動性。
### 2. 基本語法概念
- 在不同的程式語言中，變數的表示方式和定義語法可能會有所不同。以下是一些常見程式語言中變數的表示方式：
|程式語言| 變數定義方式示例| 說明|
|---|---|---|
|Python| x = 10| 直接使用 = 進行賦值，支持多種類型。|
|Java |int x = 10;| 需要指定變數類型，結尾有分號。|
|JavaScript| let x = 10;| 使用 let、const 或 var 來定義變數。|
|C++ |int x = 10;| 需要指定變數類型，結尾有分號。|
|C# |int x = 10; |類似於 Java 和 C++，需要指定類型。|
|Ruby| x = 10 |類似於 Python，無需指定類型。|
|PHP| $x = 10;| 變數以 $ 開頭，無需指定類型。|
|Swift| var x = 10| 使用 var 定義可變變數，無需指定類型。|
- 變數類型示例
- python
```Python!
name = "Alice" # 字串
age = 30 # 整數
height = 5.7 # 浮點數
```
- Java
```java!
String name = "Alice"; // 字串
int age = 30; // 整數
double height = 5.7; // 浮點數
```
- JavaScript
```javascript!
let name = "Alice"; // 字串
let age = 30; // 整數
let height = 5.7; // 浮點數
```
- C++
```C++
#include <iostream>
using namespace std;
int main() {
string name = "Alice"; // 字串
int age = 30; // 整數
double height = 5.7; // 浮點數
return 0;
}
```
- C#
```C#
string name = "Alice"; // 字串
int age = 30; // 整數
double height = 5.7; // 浮點數
```
- Ruby
```ruby!
name = "Alice" # 字串
age = 30 # 整數
height = 5.7 # 浮點數
```
- PHP
```php!
$name = "Alice"; // 字串
$age = 30; // 整數
$height = 5.7; // 浮點數
```
- Swift
```swift!
var name = "Alice" // 字串
var age = 30 // 整數
var height = 5.7 // 浮點數
```
- **變數**：存儲資料的命名位置
- 宣告變數的方式
- Python範例：
```python
x = 10 # 整數
name = "John" # 字串
```
- 變數命名規則：只能包含字母、數字和下劃線，不能以數字開頭。
- **資料型別**：數據的類型（整數、浮點數、字串、布林值）
- 整數：例如 10
- 浮點數：例如 3.14
- 字串：例如 "Hello"
- 布林值：例如 True 或 False
- **運算符**：數學運算符、比較運算符、邏輯運算符
- 數學運算符：+、-、*、/
- 比較運算符：==、!=、>、<
- 邏輯運算符：and、or、not
### 3.不同語法對運算式的表示方式
不同程式語言在運算式表示方面存在一些差異，主要體現在運算符的符號、優先級和結合性等方面。以下是一些常見程式語言中運算式的表示方式示例：
#### 基本運算符
|運算符|描述|Python|Java|JavaScript|C++|C#|Ruby|PHP|Swift|
|---|---|----|---|---|---|---|---|---|---|
|+ |加法| +| +| +| +| +| +| +| +|
|- |減法| -| -| -| -| -| -| -| -|
|* |乘法| *| *| *| *| *| *| *| *|
|/ |除法| /| /| /| /| /| /| /| /|
|% |取餘數（模運算）| %| %| %| %| %| %| %| %|
|** |指數運算| ** |**| **| **| **| **| **| **|
#### 邏輯運算符
|運算符|描述|Python|Java|JavaScript|C++|C#|Ruby|PHP|Swift|
|---|---|----|---|---|---|---|---|---|---|
|== |等於| ==| ==| ==| ==| ==| ==| ==| ==|
|!= |不等於| !=| !=| !=| !=| !=| !=| !=| !=|
|> |大於| >| >| >| >| >| >| >| >|
|< |小於| <| <| <| <| <| <| <| <|
|>= |大於等於| >=| >=| >=| >=| >=| >=| >=| >=|
|<= |小於等於| <=| <=| <=| <=| <=| <=| <=| <=|
|and| 邏輯與 |and| &&| &&| &&| &&| &&| &&| &&|
|or |邏輯或| or|
|not| 邏輯非| not |! |! |! |! |! |! |!|
#### 賦值運算符
|運算符|描述|Python|Java|JavaScript|C++|C#|Ruby|PHP|Swift|
|---|---|----|---|---|---|---|---|---|---|
|= |賦值 |= |= |= |= |= |= |= |=|
|+= |加法賦值| +=| +=| +=| +=| +=| +=| +=| +=|
|-= |減法賦值| -=| -=| -=| -=| -=| -=| -=| -=|
|*= |乘法賦值| *=| *=| *=| *=| *=| *=| *=| *=|
|/= |除法賦值| /=| /=| /=| /=| /=| /=| /=| /=|
|%= |取餘數賦值| %= |%= |%= |%= |%= |%= |%= |%=|
|**=| 指數賦值| **=| **=| **=| **=| **=| **=| **=| **=|
#### 其他運算符
|運算符|描述|Python|Java|JavaScript|C++|C#|Ruby|PHP|Swift|
|---|---|----|---|---|---|---|---|---|---|
|**. ** |成員訪問| .| .| .| .| .| .| ->| .|
|**[] **| 索引訪問| []| []| []| []| []| []| []| []|
|**() **| 函數調用| ()| ()| ()| ()| ()| ()| ()| ()|
#### 優先級和結合性
不同語言的運算符優先級和結合性可能略有不同，建議查閱相關語言的文檔以獲取詳細信息。
示例
```Python!
# python
result = (10 + 5) * 2 # 計算結果為 30
```
```Java!
# java
int result = (10 + 5) * 2; // 計算結果為 30
```
```JavaScript!
# JavaScript
let result = (10 + 5) * 2; // 計算結果為 30
```
```C++
# C++
int result = (10 + 5) * 2; // 計算結果為 30
```
```C#
# C#
int result = (10 + 5) * 2; // 計算結果為 30
```
```Ruby!
# Ruby
result = (10 + 5) * 2 # 計算結果為 30
```
```PHP!
# PHP
$result = (10 + 5) * 2; // 計算結果為 30
```
```Swift!
# Swift
let result = (10 + 5) * 2 // 計算結果為 30
```
#### 小結
不同程式語言的運算式表示方式各有特點，了解這些差異可以幫助你更有效地理解和編寫程式碼。建議在學習程式設計時，仔細閱讀相關語言的文檔，以掌握其運算符的用法和優先級。
# 第3週上課內容：控制結構
### 1. 不同語法對控制結構 if、else、elif 的表示方式
在不同的程式語言中，控制結構 if、else 和 elif 的表示方式可能略有不同，但其基本邏輯和功能是相同的。以下是一些常見程式語言中控制結構的表示方式示例：
#### if 語句
|程式語言| if 語句示例| 說明|
|---|---|---|
|Python |if condition: |使用 : 結尾，縮進表示程式區塊。|
|Java |if (condition) { ... }| 使用 {} 包裹程式區塊。|
|JavaScript| if (condition) { ... }| 使用 {} 包裹程式區塊。|
|C++ |if (condition) { ... } |使用 {} 包裹程式區塊。|
|C# |if (condition) { ... } |使用 {} 包裹程式區塊。|
|Ruby |if condition then ... end| 使用 then 和 end 標記程式區塊。|
|PHP |if (condition) { ... } |使用 {} 包裹程式區塊。|
|Swift |if condition { ... } |使用 {} 包裹程式區塊。|
#### else 語句
|程式語言 |else 語句示例 |說明|
|---|---|---|
|Python |else: |使用 : 結尾，縮進表示程式區塊。|
|Java |else { ... } |使用 {} 包裹程式區塊。|
|JavaScript |else { ... } |使用 {} 包裹程式區塊。|
|C++ |else { ... } |使用 {} 包裹程式區塊。|
|C# |else { ... } |使用 {} 包裹程式區塊。|
|Ruby |else ... end |使用 else 和 end 標記程式區塊。|
|PHP |else { ... } |使用 {} 包裹程式區塊。|
|Swift |else { ... } |使用 {} 包裹程式區塊。|
#### elif 語句
|程式語言 |elif 語句示例 |說明|
|---|---|---|
|Python |elif condition: |使用 : 結尾，縮進表示程式區塊。|
|Java |else if (condition) { ... } |使用 else if 進行多重條件判斷。|
|JavaScript |else if (condition) { ... } |使用 else if 進行多重條件判斷。|
|C++ |else if (condition) { ... } |使用 else if 進行多重條件判斷。|
|C# |else if (condition) { ... } |使用 else if 進行多重條件判斷。|
|Ruby |elsif condition then ... end |使用 elsif 和 end 標記程式區塊。|
|PHP |elseif (condition) { ... } |使用 elseif 進行多重條件判斷。|
|Swift |else if condition { ... } |使用 else if 進行多重條件判斷。|
### 第一次段考作業
```python!
radius = float(input("請輸入圓形的半徑: "))
area = 3.14159 * radius * radius
print("圓形的面積是:", area)
```
:::spoiler
- 輸入半徑：5
- 程式輸出：圓形的面積是: 78.53975
:::
---
```python!
score1 = int(input("請輸入第一個分數: "))
score2 = int(input("請輸入第二個分數: "))
score3 = int(input("請輸入第三個分數: "))
average_score = (score1 + score2 + score3) / 3
print("平均分數是:", average_score)
```
:::spoiler
- 輸入分數：80, 90, 75
- 程式輸出：平均分數是: 81.66666666666667
:::
---
```python!
original_price = float(input("請輸入商品原價: "))
discount_rate = float(input("請輸入折扣率 (例如 0.2 代表 20%): "))
discount_price = original_price * (1 - discount_rate)
print("折扣價是:", discount_price)
```
:::spoiler
- 輸入原價：100
- 輸入折扣率：0.15
- 程式輸出：折扣價是: 85.0
:::
#### 示例
- Python
```python!
age = 25
if age < 18:
print("未成年")
elif age >= 18 and age < 65:
print("成年")
else:
print("老年")
```
- Java
```java!
int age = 25;
if (age < 18) {
System.out.println("未成年");
} else if (age >= 18 && age < 65) {
System.out.println("成年");
} else {
System.out.println("老年");
}
```
- JavaScript
```javascript!
let age = 25;
if (age < 18) {
console.log("未成年");
} else if (age >= 18 && age < 65) {
console.log("成年");
} else {
console.log("老年");
}
```
- C++
```C++
#include <iostream>
using namespace std;
int main() {
int age = 25;
if (age < 18) {
cout << "未成年" << endl;
} else if (age >= 18 && age < 65) {
cout << "成年" << endl;
} else {
cout << "老年" << endl;
}
return 0;
}
```
- C#
```
using System;
class Program {
static void Main(string[] args) {
int age = 25;
if (age < 18) {
Console.WriteLine("未成年");
} else if (age >= 18 && age < 65) {
Console.WriteLine("成年");
} else {
Console.WriteLine("老年");
}
}
}
```
- Ruby
```ruby!
age = 25
if age < 18
puts "未成年"
elsif age >= 18 and age < 65
puts "成年"
else
puts "老年"
end
```
- PHP
```php!
<?php
$age = 25;
if ($age < 18) {
echo "未成年";
} elseif ($age >= 18 && $age < 65) {
echo "成年";
} else {
echo "老年";
}
?>
```
- Swift
```Swift!
let age = 25
if age < 18 {
print("未成年")
} else if age >= 18 && age < 65 {
print("成年")
} else {
print("老年")
}
```
#### 小結
不同程式語言的控制結構語法略有差異，但其邏輯和功能是一致的。了解這些差異可以幫助你更有效地理解和編寫程式碼。在學習程式設計時，建議仔細閱讀相關語言的文檔，以掌握其控制結構的用法和語法規則。
---
第二次段考作業
https://blockly.games/?lang=zh-hant
:::spoiler
:::
https://hourofcode.com/mchoc
電競訓練營：人工智能聯盟
https://hourofcode.com/codecombatesports
---
### 2. 不同語法對控制結構 For While 的表示方式
以下是不同語法對控制結構 For 和 While 的表示方式：
- **C 語言**
- **For 迴圈**
```c
for (initialization; condition; increment) {
// code to be executed
}
# 初始化;狀態;增量
```
- **While 迴圈**
```c
while (condition) {
// code to be executed
}
```
- **Python 語言**
- **For 迴圈**
```python
for item in iterable:
# code to be executed
```
- **While 迴圈**
```python
while condition:
# code to be executed
```
- **JavaScript 語言**
- **For 迴圈**
```javascript
for (initialization; condition; increment) {
// code to be executed
}
```
- **While 迴圈**
```javascript
while (condition) {
// code to be executed
}
```
- **Java 語言**
- **For 迴圈**
```java
for (initialization; condition; increment) {
// code to be executed
}
```
- **While 迴圈**
```java
while (condition) {
// code to be executed
}
```
- **PHP 語言**
- **For 迴圈**
```php
for (initialization; condition; increment) {
// code to be executed
}
```
- **While 迴圈**
```php
while (condition) {
// code to be executed
}
```
- **Go 語言**
- **For 迴圈**
```go
for initialization; condition; increment {
// code to be executed
}
```
- **While 迴圈**
```go
for condition {
// code to be executed
}
```
- **Swift 語言**
- **For 迴圈**
```swift
for item in iterable {
// code to be executed
}
```
- **While 迴圈**
```swift
while condition {
// code to be executed
}
```
- **Kotlin 語言**
- **For 迴圈**
```kotlin
for (item in iterable) {
// code to be executed
}
```
- **While 迴圈**
```kotlin
while (condition) {
// code to be executed
}
```
- **Ruby 語言**
- **For 迴圈**
```ruby
for item in iterable do
# code to be executed
end
```
- **While 迴圈**
```ruby
while condition do
# code to be executed
end
```
- **C# 語言**
- **For 迴圈**
```csharp
for (initialization; condition; increment) {
// code to be executed
}
```
- **While 迴圈**
```csharp
while (condition) {
// code to be executed
}
```
**小結**
不同的程式語言對於 For 和 While 迴圈的語法細節可能略有不同，但它們的基本概念是相同的：
* **For 迴圈**及**While迴圈**皆是允許重複執行一段程式碼，直到滿足特定條件為止。
---
以下是一些 For 和 While 迴圈的範例，以說明它們在不同程式語言中的用法：
**1. C 語言**
* **For 迴圈：印出 1 到 10 的數字**
```c
#include <stdio.h>
int main() {
for (int i = 1; i <= 10; i++) {
printf("%d\n", i);
}
return 0;
}
```
* **While 迴圈：計算 1 到 10 的總和**
```c
#include <stdio.h>
int main() {
int i = 1;
int sum = 0;
while (i <= 10) {
sum += i;
i++;
}
printf("總和為：%d\n", sum);
return 0;
}
```
**2. Python 語言**
* **For 迴圈：印出清單中的每個項目**
```python
my_list = ["蘋果", "香蕉", "橘子"]
for fruit in my_list:
print(fruit)
```
* **While 迴圈：輸入數字直到輸入 0**
```python
number = 1
while number != 0:
number = int(input("請輸入一個數字 (輸入 0 結束): "))
print("您輸入的數字是:", number)
```
**3. JavaScript 語言**
* **For 迴圈：印出 1 到 5 的平方**
```javascript
for (let i = 1; i <= 5; i++) {
console.log(i * i);
}
```
* **While 迴圈：輸入字串直到輸入 "結束"**
```javascript
let input = "";
while (input !== "結束") {
input = prompt("請輸入一個字串 (輸入 \"結束\" 結束): ");
console.log("您輸入的字串是:", input);
}
```
**4. Java 語言**
* **For 迴圈：計算 1 到 5 的總和**
```java
public class Main {
public static void main(String[] args) {
int sum = 0;
for (int i = 1; i <= 5; i++) {
sum += i;
}
System.out.println("總和為：" + sum);
}
}
```
* **While 迴圈：輸入數字直到輸入負數**
```java
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int number = 1;
while (number >= 0) {
System.out.print("請輸入一個數字 (輸入負數結束): ");
number = scanner.nextInt();
System.out.println("您輸入的數字是：" + number);
}
}
}
```
**5. PHP 語言**
* **For 迴圈：印出陣列中的每個元素**
```php
$fruits = array("蘋果", "香蕉", "橘子");
for ($i = 0; $i < count($fruits); $i++) {
echo $fruits[$i] . "<br>";
}
```
* **While 迴圈：輸入文字直到輸入 "結束"**
```php
$input = "";
while ($input !== "結束") {
$input = readline("請輸入一個文字 (輸入 \"結束\" 結束): ");
echo "您輸入的文字是：" . $input . "<br>";
}
```
**6. Go 語言**
* **For 迴圈：印出 1 到 5 的偶數**
```go
package main
import "fmt"
func main() {
for i := 1; i <= 5; i++ {
if i%2 == 0 {
fmt.Println(i)
}
}
}
```
* **While 迴圈：輸入數字直到輸入 0**
```go
package main
import "fmt"
func main() {
number := 1
for number != 0 {
fmt.Print("請輸入一個數字 (輸入 0 結束): ")
fmt.Scanln(&number)
fmt.Println("您輸入的數字是:", number)
}
}
```
**7. Swift 語言**
* **For 迴圈：印出 1 到 10 的數字**
```swift
for i in 1...10 {
print(i)
}
```
* **While 迴圈：輸入文字直到輸入 "結束"**
```swift
var input = ""
while input != "結束" {
input = readLine()!
print("您輸入的文字是:", input)
}
```
**8. Kotlin 語言**
* **For 迴圈：印出 1 到 5 的平方**
```kotlin
for (i in 1..5) {
println(i * i)
}
```
* **While 迴圈：輸入數字直到輸入負數**
```kotlin
import java.util.*
fun main() {
val scanner = Scanner(System.`in`)
var number = 1
while (number >= 0) {
print("請輸入一個數字 (輸入負數結束): ")
number = scanner.nextInt()
println("您輸入的數字是：" + number)
}
}
```
**9. Ruby 語言**
* **For 迴圈：印出陣列中的每個元素**
```ruby
fruits = ["蘋果", "香蕉", "橘子"]
fruits.each do |fruit|
puts fruit
end
```
* **While 迴圈：輸入文字直到輸入 "結束"**
```ruby
input = ""
while input != "結束"
input = gets.chomp
puts "您輸入的文字是：" + input
end
```
**10. C# 語言**
* **For 迴圈：計算 1 到 5 的總和**
```csharp
using System;
public class Program {
public static void Main(string[] args) {
int sum = 0;
for (int i = 1; i <= 5; i++) {
sum += i;
}
Console.WriteLine("總和為：" + sum);
}
}
```
* **While 迴圈：輸入數字直到輸入負數**
```csharp
using System;
public class Program {
public static void Main(string[] args) {
int number = 1;
while (number >= 0) {
Console.Write("請輸入一個數字 (輸入負數結束): ");
number = Convert.ToInt32(Console.ReadLine());
Console.WriteLine("您輸入的數字是：" + number);
}
}
}
```
# 第4週上課內容：函數與模組
### 不同語法對函數與模組的表示方式：
以下是一些常見程式語言中函數和模組的表示方式：
**1. C 語言**
* **函數：**
```c
#include <stdio.h>
// 函數定義
int sum(int a, int b) {
return a + b;
}
int main() {
int result = sum(3, 5);
printf("3 + 5 = %d\n", result);
return 0;
}
```
* **模組：**
C 語言本身沒有明確的模組概念，但可以使用頭文件（.h）和源文件（.c）來模擬模組化。
**2. Python 語言**
* **函數：**
```python
def sum(a, b):
return a + b
result = sum(3, 5)
print("3 + 5 =", result)
```
* **模組：**
Python 使用檔案來表示模組。例如，一個名為 `my_module.py` 的檔案可以包含以下程式碼：
```python
def sum(a, b):
return a + b
def greet(name):
print("Hello,", name)
```
然後，在另一個檔案中，可以使用 `import` 語句導入模組：
```python
import my_module
result = my_module.sum(3, 5)
print("3 + 5 =", result)
my_module.greet("Alice")
```
**3. JavaScript 語言**
* **函數：**
```javascript
function sum(a, b) {
return a + b;
}
let result = sum(3, 5);
console.log("3 + 5 =", result);
```
* **模組：**
JavaScript 使用 `export` 和 `import` 來定義和導入模組。例如，一個名為 `my_module.js` 的檔案可以包含以下程式碼：
```javascript
export function sum(a, b) {
return a + b;
}
export function greet(name) {
console.log("Hello,", name);
}
```
然後，在另一個檔案中，可以使用 `import` 語句導入模組：
```javascript
import { sum, greet } from './my_module.js';
let result = sum(3, 5);
console.log("3 + 5 =", result);
greet("Alice");
```
**4. Java 語言**
* **函數：**
```java
public class Main {
public static int sum(int a, int b) {
return a + b;
}
public static void main(String[] args) {
int result = sum(3, 5);
System.out.println("3 + 5 = " + result);
}
}
```
* **模組：**
Java 使用類別來表示模組。例如，一個名為 `MyModule.java` 的檔案可以包含以下程式碼：
```java
public class MyModule {
public static int sum(int a, int b) {
return a + b;
}
public static void greet(String name) {
System.out.println("Hello, " + name);
}
}
```
然後，在另一個檔案中，可以使用 `import` 語句導入模組：
```java
import MyModule;
public class Main {
public static void main(String[] args) {
int result = MyModule.sum(3, 5);
System.out.println("3 + 5 = " + result);
MyModule.greet("Alice");
}
}
```
**5. Go 語言**
* **函數：**
```go
package main
import "fmt"
func sum(a, b int) int {
return a + b
}
func main() {
result := sum(3, 5)
# := 表示聲明一個新變數，並將 sum(3, 5) 的結果賦予它。
# := 運算子只能在 函數內部 使用，不能在函數外部使用。
fmt.Println("3 + 5 =", result)
}
```
* **模組：**
Go 使用包（package）來表示模組。例如，一個名為 `my_module` 的包可以包含以下程式碼：
```go
package my_module
func sum(a, b int) int {
return a + b
}
func greet(name string) {
fmt.Println("Hello,", name)
}
```
然後，在另一個檔案中，可以使用 `import` 語句導入模組：
```go
package main
import "fmt"
import "my_module"
func main() {
result := my_module.sum(3, 5)
fmt.Println("3 + 5 =", result)
my_module.greet("Alice")
}
```
**6. Swift 語言**
* **函數：**
```swift
func sum(a: Int, b: Int) -> Int {
return a + b
}
let result = sum(a: 3, b: 5)
print("3 + 5 =", result)
```
* **模組：**
Swift 使用檔案來表示模組。例如，一個名為 `MyModule.swift` 的檔案可以包含以下程式碼：
```swift
func sum(a: Int, b: Int) -> Int {
return a + b
}
func greet(name: String) {
print("Hello,", name)
}
```
然後，在另一個檔案中，可以使用 `import` 語句導入模組：
```swift
import MyModule
let result = MyModule.sum(a: 3, b: 5)
print("3 + 5 =", result)
MyModule.greet(name: "Alice")
```
**7. Kotlin 語言**
* **函數：**
```kotlin
fun sum(a: Int, b: Int): Int {
return a + b
}
fun main() {
val result = sum(3, 5)
println("3 + 5 = $result")
}
```
* **模組：**
Kotlin 使用檔案來表示模組。例如，一個名為 `MyModule.kt` 的檔案可以包含以下程式碼：
```kotlin
package my_module
fun sum(a: Int, b: Int): Int {
return a + b
}
fun greet(name: String) {
println("Hello, $name")
}
```
然後，在另一個檔案中，可以使用 `import` 語句導入模組：
```kotlin
import my_module.*
fun main() {
val result = sum(3, 5)
println("3 + 5 = $result")
greet("Alice")
}
```
**8. PHP 語言**
* **函數：**
```php
function sum($a, $b) {
return $a + $b;
}
$result = sum(3, 5);
echo "3 + 5 = " . $result . "<br>";
```
* **模組：**
PHP 使用檔案來表示模組。例如，一個名為 `my_module.php` 的檔案可以包含以下程式碼：
```php
function sum($a, $b) {
return $a + $b;
}
function greet($name) {
echo "Hello, " . $name . "<br>";
}
```
然後，在另一個檔案中，可以使用 `require` 或 `include` 語句導入模組：
```php
require "my_module.php";
$result = sum(3, 5);
echo "3 + 5 = " . $result . "<br>";
greet("Alice");
```
**9. C# 語言**
* **函數：**
```csharp
using System;
public class Program {
public static int sum(int a, int b) {
return a + b;
}
public static void Main(string[] args) {
int result = sum(3, 5);
Console.WriteLine("3 + 5 = " + result);
}
}
```
* **模組：**
C# 使用命名空間來表示模組。例如，一個名為 `MyModule` 的命名空間可以包含以下程式碼：
```csharp
namespace MyModule {
public static class MathUtils {
public static int sum(int a, int b) {
return a + b;
}
}
public static class Greetings {
public static void greet(string name) {
Console.WriteLine("Hello, " + name);
}
}
}
```
然後，在另一個檔案中，可以使用 `using` 語句導入模組：
```csharp
using System;
using MyModule;
public class Program {
public static void Main(string[] args) {
int result = MathUtils.sum(3, 5);
Console.WriteLine("3 + 5 = " + result);
Greetings.greet("Alice");
}
}
```
**10. Ruby 語言**
* **函數：**
```ruby
def sum(a, b)
return a + b
end
result = sum(3, 5)
puts "3 + 5 = #{result}"
```
* **模組：**
Ruby 使用檔案來表示模組。例如，一個名為 `my_module.rb` 的檔案可以包含以下程式碼：
```ruby
module MyModule
def self.sum(a, b)
return a + b
end
def self.greet(name)
puts "Hello, #{name}"
end
end
```
然後，在另一個檔案中，可以使用 `require` 語句導入模組：
```ruby
require "my_module"
result = MyModule.sum(3, 5)
puts "3 + 5 = #{result}"
MyModule.greet("Alice")
```
#### 以上範例可以幫助各位同學更好地理解，在不同程式語言中"函數和模組"的表示方式！
# 第5週上課內容：資料結構簡介
### 資料結構的定義、特點及應用
#### 以下是七種資料結構的詳細說明：
**1. 陣列 (Array)**
* **定義：** 陣列是一種線性資料結構，用於儲存相同資料類型的元素的集合。陣列中的元素以連續的記憶體位置儲存，並使用索引 (index) 來存取它們。索引從 0 開始，到陣列大小減 1 結束。
* **特點：**
* **元素類型相同：** 陣列只能儲存同一種資料類型的元素，例如整數、浮點數、字元等等。
* **元素以連續記憶體位置儲存：** 陣列中的元素在記憶體中是連續儲存的，這使得存取元素非常快。
* **使用索引存取元素：** 您可以使用索引來快速存取陣列中的任何元素。
* **大小固定：** 一旦宣告陣列的大小，就無法再改變。
* **應用：**
* **儲存固定大小的資料集合：** 例如儲存學生成績、一個月的溫度資料、一個遊戲中的角色屬性等等。
* **作為其他資料結構的基礎：** 例如，串列、堆疊、佇列等資料結構可以使用陣列來實現。
* **在演算法中使用：** 例如排序演算法、搜尋演算法等等。
**2. 串列 (List)**
* **定義：** 串列是一種線性資料結構，用於儲存資料元素的順序集合。串列中的元素可以是任何資料類型，並且可以動態新增或刪除。
* **特點：**
* **元素可以是任何資料類型：** 串列可以儲存不同資料類型的元素，例如整數、浮點數、字元、物件等等。
* **元素以鏈結方式儲存：** 串列中的元素以鏈結方式儲存，每個元素都指向下一個元素。
* **可以動態新增或刪除元素：** 您可以隨時新增或刪除串列中的元素，而不需要事先知道串列的大小。
* **大小可變：** 串列的大小可以根據需要動態調整。
* **應用：**
* **儲存需要動態調整大小的資料集合：** 例如購物車中的商品清單、音樂播放清單、網頁瀏覽歷史記錄等等。
* **實現其他資料結構：** 例如堆疊、佇列、樹等等。
* **在演算法中使用：** 例如排序演算法、搜尋演算法等等。
**3. 堆疊 (Stack)**
* **定義：** 堆疊是一種後進先出 (LIFO) 的資料結構。它就像一個堆疊的盤子，最後放上去的盤子會最先被拿走。
* **特點：**
* **只能從頂端新增或刪除元素：** 堆疊只能從頂端新增元素（稱為 `push`）或刪除元素（稱為 `pop`）。
* **後進先出：** 最近新增的元素會最先被刪除。
* **應用：**
* **函數呼叫堆疊：** 程式語言使用堆疊來管理函數呼叫。
* **撤銷/重做功能：** 例如文字編輯器中的撤銷/重做功能可以使用堆疊來實現。
* **表達式求值：** 例如計算器可以使用堆疊來計算表達式。
**4. 佇列 (Queue)**
* **定義：** 佇列是一種先進先出 (FIFO) 的資料結構。它就像排隊等候的人群，最先排隊的人會最先被服務。
* **特點：**
* **只能從隊尾新增元素：** 佇列只能從隊尾新增元素（稱為 `enqueue`）。
* **只能從隊頭刪除元素：** 佇列只能從隊頭刪除元素（稱為 `dequeue`）。
* **先進先出：** 最早新增的元素會最先被刪除。
* **應用：**
* **處理任務佇列：** 例如作業系統可以使用佇列來管理任務。
* **訊息佇列：** 例如網路應用程式可以使用佇列來傳送訊息。
* **打印機佇列：** 例如打印機可以使用佇列來管理打印任務。
**5. 樹 (Tree)**
* **定義：** 樹是一種非線性資料結構，由節點 (node) 組成，節點之間以父子關係連接。樹的根節點沒有父節點，而葉節點沒有子節點。
* **特點：**
* **具有層級結構：** 樹的節點按照層級排列，根節點位於最高層級。
* **根節點是樹的起始點：** 樹的根節點是樹的唯一入口點。
* **每個節點最多只有一個父節點：** 除了根節點之外，每個節點都有一個父節點。
* **每個節點可以有多個子節點：** 節點可以有任意數量的子節點。
* **應用：**
* **文件系統：** 文件系統可以使用樹來表示檔案和目錄的組織結構。
* **資料庫索引：** 資料庫可以使用樹來建立索引，以便快速搜尋資料。
* **決策樹：** 決策樹可以用於機器學習，以建立預測模型。
**6. 圖 (Graph)**
* **定義：** 圖是一種非線性資料結構，由節點 (node) 和邊 (edge) 組成。節點表示物件，邊表示節點之間的關係。
* **特點：**
* **節點和邊：** 圖由節點和邊組成，節點表示物件，邊表示節點之間的關係。
* **無方向圖和有方向圖：** 圖可以是有方向的或無方向的。在有方向圖中，邊具有方向，而在無方向圖中，邊沒有方向。
* **加權圖和無加權圖：** 圖可以是加權的或無加權的。在加權圖中，邊具有權重，而在無加權圖中，邊沒有權重。
* **應用：**
* **社交網路：** 社交網路可以使用圖來表示使用者和他們之間的關係。
* **交通網路：** 交通網路可以使用圖來表示城市、道路和交通路線。
* **電路設計：** 電路設計可以使用圖來表示電路元件和它們之間的連接。
**7. 集合 (Set)**
* **定義：** 集合是一種資料結構，用於儲存不重複的元素。集合中的元素沒有順序，並且可以是任何資料類型。
* **特點：**
* **不重複元素：** 集合中的元素不能重複。
* **無序：** 集合中的元素沒有順序。
* **可以是任何資料類型：** 集合中的元素可以是任何資料類型。
* **應用：**
* **儲存不重複的資料：** 例如儲存一個人的興趣愛好、一個班級的學生名單等等。
* **檢查元素是否存在：** 您可以使用集合來快速檢查元素是否存在於集合中。
* **在演算法中使用：** 例如排序演算法、搜尋演算法等等。
#### 不同語法對資料結構的表示方式：
以下是不同程式語言中資料結構的表示方式，涵蓋常見的資料結構與範例：
**1. 陣列 (Array)**
* **C/C++:** `int arr[5];` // 宣告一個大小為 5 的整數陣列
* **Java:** `int[] arr = new int[5];` // 宣告一個大小為 5 的整數陣列
* **Python:** `arr = [1, 2, 3, 4, 5]` // 宣告一個包含 5 個元素的整數列表
* **JavaScript:** `let arr = [1, 2, 3, 4, 5];` // 宣告一個包含 5 個元素的整數陣列
* **Go:** `arr := [5]int{1, 2, 3, 4, 5}` // 宣告一個大小為 5 的整數陣列
**2. 串列 (List)**
* **C++:** 使用 STL 中的 `std::list` 模板類別
* **Java:** 使用 `java.util.List` 接口，例如 `java.util.ArrayList`
* **Python:** `list = [1, 2, 3, 4, 5]` // 使用列表表示串列
* **JavaScript:** `let list = [1, 2, 3, 4, 5];` // 使用陣列表示串列
* **Go:** 使用 `[]int` 切片表示串列
**3. 堆疊 (Stack)**
* **C++:** 使用 STL 中的 `std::stack` 模板類別
* **Java:** 使用 `java.util.Stack` 類別
* **Python:** 使用列表，並使用 `append()` 和 `pop()` 方法模擬堆疊
* **JavaScript:** 使用陣列，並使用 `push()` 和 `pop()` 方法模擬堆疊
* **Go:** 使用 `[]int` 切片，並使用 `append()` 和 `pop()` 方法模擬堆疊
**4. 佇列 (Queue)**
* **C++:** 使用 STL 中的 `std::queue` 模板類別
* **Java:** 使用 `java.util.Queue` 接口，例如 `java.util.LinkedList`
* **Python:** 使用列表，並使用 `append()` 和 `pop(0)` 方法模擬佇列
* **JavaScript:** 使用陣列，並使用 `push()` 和 `shift()` 方法模擬佇列
* **Go:** 使用 `[]int` 切片，並使用 `append()` 和 `pop(0)` 方法模擬佇列
**5. 樹 (Tree)**
* **C++:** 使用自訂資料結構或 STL 中的 `std::map` 或 `std::set` 模擬樹
* **Java:** 使用自訂資料結構或 `java.util.TreeMap` 或 `java.util.TreeSet` 模擬樹
* **Python:** 使用自訂資料結構或字典 (dictionary) 模擬樹
* **JavaScript:** 使用自訂資料結構或 `Map` 或 `Set` 模擬樹
* **Go:** 使用自訂資料結構或 `map` 模擬樹
**6. 圖 (Graph)**
* **C++:** 使用自訂資料結構或 STL 中的 `std::map` 或 `std::set` 模擬圖
* **Java:** 使用自訂資料結構或 `java.util.HashMap` 或 `java.util.HashSet` 模擬圖
* **Python:** 使用自訂資料結構或字典 (dictionary) 模擬圖
* **JavaScript:** 使用自訂資料結構或 `Map` 或 `Set` 模擬圖
* **Go:** 使用自訂資料結構或 `map` 模擬圖
**7. 集合 (Set)**
* **C++:** 使用 STL 中的 `std::set` 或 `std::unordered_set` 模板類別
* **Java:** 使用 `java.util.Set` 接口，例如 `java.util.HashSet` 或 `java.util.TreeSet`
* **Python:** 使用 `set` 資料類型
* **JavaScript:** 使用 `Set` 資料類型
* **Go:** 使用 `map` 模擬集合，或者使用 `set` 包
**範例：**
* **Python:**
```python
# 陣列
numbers = [1, 2, 3, 4, 5]
# 串列
my_list = [1, 2, 3, 4, 5]
# 堆疊
stack = []
stack.append(1)
stack.append(2)
stack.pop()
# 佇列
queue = []
queue.append(1)
queue.append(2)
queue.pop(0)
# 樹
tree = {
'root': {
'left': {
'value': 1
},
'right': {
'value': 2
}
}
}
# 圖
graph = {
'A': ['B', 'C'],
'B': ['A', 'D'],
'C': ['A', 'E'],
'D': ['B'],
'E': ['C']
}
# 集合
my_set = {1, 2, 3, 4, 5}
```
Sign in with Wallet
Connect another wallet