Python 字典與字串操作技術

Python 提供了豐富的字串和字典操作方法，熟練運用這些技巧能大幅提升程式碼的效率和可讀性。本文將會介紹如何有效地運用這些方法，包含字典的建立、存取、更新，以及字串的索引、切片、格式化等。透過理解這些方法，能更靈活地處理和分析文字與資料。此外，我們也將探討如何使用 Python 內建函式和方法來驗證國際象棋棋盤的組態，以及如何使用字典來儲存和管理遊戲物品。這些實務案例有助於讀者將理論知識應用到實際的程式開發中，並學習如何設計更具結構性和效率的程式碼。

步驟 3：列印當前棋盤

我們將定義一個 print_chessboard() 函式，該函式接受棋盤字典作為輸入，然後在螢幕上列印出反映棋盤上棋子的棋盤。為了實作這一點，我們需要建立一個包含 64 個字串的列表，以替換 BOARD_TEMPLATE 字串中的 {} 對。這些字串代表著棋子（如 'wB' 和 'bQ'）或空方格。

實作 `print_chessboard()` 函式

def print_chessboard(board):
    # 定義棋盤範本
    BOARD_TEMPLATE = """
    3 | {} ||{}|| {} ||{}|| {} ||{}|| {} ||{}||
    |____||||||____||||||____||||||____||||||
    |||||| |||||| |||||| |||||| |
    2 ||{}|| {} ||{}|| {} ||{}|| {} ||{}|| {} |
    ||||||____||||||____||||||____||||||____|
    | |||||| |||||| |||||| |||||| |
    1 | {} ||{}|| {} ||{}|| {} ||{}|| {} ||{}||
    |____||||||____||||||____||||||____||||||
    """

    # 建立一個列表來儲存 64 個方格的字串
    squares = []

    # 初始化是否為白方格的旗標
    is_white_square = True

    # 內嵌迴圈遍歷所有 64 個方格
    for y in '87654321':
        for x in 'abcdefgh':
            # 根據棋盤字典取得當前方格的棋子
            piece = board.get((x, y))

            # 如果方格不為空，加入棋子字串；否則，根據方格顏色加入適當的空方格字串
            if piece:
                squares.append(piece)
            elif is_white_square:
                squares.append('||')  # 白方格
            else:
                squares.append(' ')  # 黑方格

            # 切換方格顏色
            is_white_square = not is_white_square

        # 每行結束後切換方格顏色
        is_white_square = not is_white_square

    # 使用 format() 方法替換 BOARD_TEMPLATE 中的 {} 對
    print(BOARD_TEMPLATE.format(*squares))

示例使用

# 定義一個簡單的棋盤字典
chessboard = {
    ('a', '1'): 'wR',  # 白色國王在 a1
    ('h', '1'): 'wK',  # 白色皇后在 h1
    ('a', '8'): 'bR',  # 黑色國王在 a8
    ('h', '8'): 'bK',  # 黑色皇后在 h8
}

# 列印棋盤
print_chessboard(chessboard)

這個示例展示瞭如何使用 print_chessboard() 函式來列印一個簡單的棋盤組態。根據提供的棋盤字典，函式會在螢幕上繪製出相應的棋盤，並將指定的棋子放在對應的方格中。

使用Python建立互動式西洋棋板

代表西洋棋板

要建立一個互動式西洋棋板，我們需要先定義如何代表西洋棋板。這裡，我們使用一個Python字典來代表西洋棋板，其中鍵是方格字串（如’a8’），值是棋子字串（如’bQ’）。

顯示西洋棋板

下一步是建立一個函式來顯示西洋棋板。這個函式被稱為print_chessboard()，它接受一個代表西洋棋板的字典作為引數。

def print_chessboard(board):
    #...

在這個函式中，我們使用兩個巢狀的迴圈來生成64個方格的字串列表。外層迴圈遍歷行，內層迴圈遍歷列。如果某個方格存在於字典中，我們追加相應的棋子字串；否則，我們追加空白方格字串。

squares = []
for y in range(8, 0, -1):
    for x in 'abcdefgh':
        if x + str(y) in board.keys():
            squares.append(board[x + str(y)])
        else:
            #...

切換方格顏色

為了正確顯示西洋棋板的棋格顏色，我們需要在每個方格之間切換顏色。這可以透過一個布林變數is_white_square來實作。

is_white_square = True
for y in range(8, 0, -1):
    for x in 'abcdefgh':
        #...
        is_white_square = not is_white_square
    is_white_square = not is_white_square

格式化輸出

最後，我們使用format()方法將方格字串列表格式化為一個字串，並列印預出來。

print(BOARD_TEMPLATE.format(*squares))

主程式

在主程式中，我們定義了一些操作來操控西洋棋板，包括移動棋子、刪除棋子、設定方格上的棋子、重置棋盤和清除棋盤。

print('Interactive Chessboard')
#...

這些操作可以透過修改代表西洋棋板的字典來實作，並且在每次操作後呼叫print_chessboard()函式來更新顯示。

程式碼實作

以下是完整的程式碼實作：

BOARD_TEMPLATE = '''
  a  b  c  d  e  f  g  h
8 {} {} {} {} {} {} {} {}
7 {} {} {} {} {} {} {} {}
6 {} {} {} {} {} {} {} {}
5 {} {} {} {} {} {} {} {}
4 {} {} {} {} {} {} {} {}
3 {} {} {} {} {} {} {} {}
2 {} {} {} {} {} {} {} {}
1 {} {} {} {} {} {} {} {}
'''

def print_chessboard(board):
    squares = []
    is_white_square = True
    for y in range(8, 0, -1):
        for x in 'abcdefgh':
            if x + str(y) in board.keys():
                squares.append(board[x + str(y)])
            else:
                if is_white_square:
                    squares.append(' ')
                else:
                    squares.append(' ')
            is_white_square = not is_white_square
        is_white_square = not is_white_square
    print(BOARD_TEMPLATE.format(*squares))

# 主程式
board = {
    'a8': 'r', 'b8': 'n', 'c8': 'b', 'd8': 'q', 'e8': 'k', 'f8': 'b', 'g8': 'n', 'h8': 'r',
    'a7': 'p', 'b7': 'p', 'c7': 'p', 'd7': 'p', 'e7': 'p', 'f7': 'p', 'g7': 'p', 'h7': 'p',
    'a2': 'P', 'b2': 'P', 'c2': 'P', 'd2': 'P', 'e2': 'P', 'f2': 'P', 'g2': 'P', 'h2': 'P',
    'a1': 'R', 'b1': 'N', 'c1': 'B', 'd1': 'Q', 'e1': 'K', 'f1': 'B', 'g1': 'N', 'h1': 'R',
}

print('Interactive Chessboard')
print_chessboard(board)

這個程式碼建立了一個基本的互動式西洋棋板，並提供了一些操作來操控棋盤。

內容解密：

在這個程式碼中，我們可以看到一個簡單的棋盤遊戲的命令列介面。程式碼首先印出一些指令，告訴使用者如何與程式互動。然後，它進入一個無限迴圈，等待使用者的輸入。

當使用者輸入命令時，程式碼會將輸入的字串分割成一個列表，存放在 response 變數中。然後，它會根據 response 列表中的第一個元素（即命令）來執行相應的動作。

如果使用者輸入的是 move 命令，程式碼會將棋子從原始位置（存放在 response[1] 中）移動到新的位置（存放在 response[2] 中）。然後，它會刪除原始位置的鍵值對，以達到移動棋子的效果。

if response[0] == 'move':
    # 將棋子從原始位置移動到新的位置
    main_board[response[2]] = main_board[response[1]]
    # 刪除原始位置的鍵值對
    del main_board[response[1]]

圖表翻譯：

在這個圖表中，我們可以看到程式碼如何處理不同的命令，並根據命令型別執行相應的動作。當使用者輸入 move 命令時，程式碼會將棋子從原始位置移動到新的位置，並更新棋盤。

程式碼解析：國際象棋棋盤模擬器

以下是程式碼的重構版本，包含詳細註解和Plantuml圖表，以便更好地理解程式的邏輯和流程。

# 初始化國際象棋棋盤
main_board = {}

# 定義一個函式來處理使用者輸入
def handle_user_input(response):
    # 移除棋子
    if response[0] == 'remove':
        # 刪除指定棋子
        del main_board[response[1]]
    
    # 設定棋子
    elif response[0] == 'set':
        # 設定指定棋子
        main_board[response[1]] = response[2]
    
    # 重置棋盤
    elif response[0] == 'reset':
        # 重置棋盤為初始組態
        main_board = {}
    
    # 清除棋盤
    elif response[0] == 'clear':
        # 清除所有棋子
        main_board = {}
    
    # 填充棋盤
    elif response[0] == 'fill':
        # 填充所有格子為指定棋子
        for y in '87654321':
            for x in 'abcdefgh':
                main_board[x + y] = response[1]

# 測試程式
response = ['remove', 'e2']
handle_user_input(response)
print(main_board)

response = ['set', 'e2', 'wP']
handle_user_input(response)
print(main_board)

response = ['reset']
handle_user_input(response)
print(main_board)

response = ['clear']
handle_user_input(response)
print(main_board)

response = ['fill', 'wP']
handle_user_input(response)
print(main_board)

程式流程圖

圖表翻譯

此Plantuml圖表展示了程式的流程，從使用者輸入開始，根據輸入型別進行不同的處理，包括移除棋子、設定棋子、重置棋盤、清除棋盤和填充棋盤。每個步驟都對應到程式碼中的特定部分，清晰地展示了程式的邏輯和流程。

使用巢狀字典和列表儲存複雜資料

在建模複雜系統時，可能需要使用巢狀字典和列表來儲存資料。列表適合儲存有序的值序列，而字典則適合關聯鍵與值。在下面的範例中，我們將使用字典來儲存客人帶來的野餐物品的資料。

野餐嘉賓資料結構

all_guests = {
    'Alice': {'apples': 5, 'pretzels': 2},
    'Bob': {'ham sandwiches': 3, 'apple pies': 1},
    'Carol': {'cups': 3, 'apple pies': 2}
}

計算總攜帶數量

def total_brought(guests, item):
    num_brought = 0
    for k, v in guests.items():
        num_brought += v.get(item, 0)
    return num_brought

print('Number of things being brought:')
print(' - Apples:', total_brought(all_guests, 'apples'))
print(' - Pretzels:', total_brought(all_guests, 'pretzels'))
print(' - Ham sandwiches:', total_brought(all_guests, 'ham sandwiches'))
print(' - Apple pies:', total_brought(all_guests, 'apple pies'))
print(' - Cups:', total_brought(all_guests, 'cups'))

在 total_brought() 函式中，迴圈遍歷 guests 字典的鍵值對。對於每個客人，若該客人攜帶了指定的物品，則將該物品的數量加到 num_brought 中。若客人未攜帶該物品，則 get() 方法傳回 0。

結果

Number of things being brought:
 - Apples: 5
 - Pretzels: 2
 - Ham sandwiches: 3
 - Apple pies: 3
 - Cups: 3

這個範例展示瞭如何使用巢狀字典和列表來儲存複雜資料，並如何使用迴圈和 get() 方法來計算總攜帶數量。

字典（Dictionary）概述

字典是一種可以包含多個值的資料結構，包括其他列表和字典。它們的用途在於能夠將一個專案（鍵）對映到另一個專案（值），而列表則只是包含一系列按順序排列的值。程式碼可以使用方括號來存取字典內的值，就像列表一樣。不過，與列表不同，字典可以使用各種資料型別作為鍵，包括整數、浮點數、字串或元組。

字典的基本結構

一個空字典的程式碼如下：

my_dict = {}

一個具有鍵值對的字典如下：

my_dict = {'foo': 42}

字典與列表的主要區別

字典和列表都是可以包含多個值的資料結構，但它們在存取值的方式上有所不同。列表使用整數索引來存取值，而字典使用鍵來存取值。

存取字典值

如果試圖存取一個不存在的鍵，例如 spam['foo']，而 spam 是 {'bar': 100}，則會引發一個 KeyError。

檢查鍵是否存在

可以使用 in 運算元來檢查一個鍵是否存在於字典中，例如 'cat' in spam。也可以使用 spam.keys() 來取得字典中的所有鍵。

檢查值是否存在

可以使用 in 運算元來檢查一個值是否存在於字典中，例如 'cat' in spam.values()。

快速新增鍵值對

如果鍵不存在於字典中，可以使用以下程式碼快速新增一個鍵值對：

if 'color' not in spam:
    spam['color'] = 'black'

或者，可以使用 setdefault() 方法：

spam.setdefault('color', 'black')

美化字典輸出

可以使用 pprint 模組和 pprint() 函式來美化字典輸出：

import pprint
pprint.pprint(my_dict)

練習題目

空字典的程式碼是什麼？
一個具有鍵值對的字典的程式碼是什麼？
字典和列表的主要區別是什麼？
如果試圖存取一個不存在的鍵，會發生什麼？
如何檢查一個鍵是否存在於字典中？
如何檢查一個值是否存在於字典中？
快速新增鍵值對的方法是什麼？
哪個模組和函式可以用來美化字典輸出？

內容解密：

上述程式碼展示瞭如何使用字典來儲存和存取資料。字典是一種強大的資料結構，可以用來模擬現實世界中的物體和關係。透過使用字典，可以建立複雜的資料模型，並使用方括號和鍵來存取值。同時，也可以使用 in 運算元來檢查鍵和值是否存在於字典中。

圖表翻譯：

以下是字典的基本結構和操作的 Plantuml 圖表：這個圖表展示瞭如何建立和操作字典，包括新增鍵值對、存取值、檢查鍵和值是否存在，以及美化輸出。

Chess Dictionary Validator

程式碼

def isValidChessBoard(board):
    # 檢查棋盤是否為字典
    if not isinstance(board, dict):
        return False

    # 初始化黑白王的數量
    black_king = 0
    white_king = 0

    # 初始化棋子的數量
    black_pieces = 0
    white_pieces = 0

    # 初始化兵的數量
    black_pawns = 0
    white_pawns = 0

    # 遍歷棋盤
    for piece in board.values():
        # 檢查棋子是否為字串
        if not isinstance(piece, str):
            return False

        # 檢查棋子的顏色
        if piece[0] not in ['b', 'w']:
            return False

        # 檢查黑王的數量
        if piece == 'bK':
            black_king += 1
        # 檢查白王的數量
        elif piece == 'wK':
            white_king += 1

        # 檢查黑棋子的數量
        if piece[0] == 'b':
            black_pieces += 1
            # 檢查黑兵的數量
            if piece == 'bP':
                black_pawns += 1
        # 檢查白棋子的數量
        elif piece[0] == 'w':
            white_pieces += 1
            # 檢查白兵的數量
            if piece == 'wP':
                white_pawns += 1

    # 檢查棋盤是否有效
    if black_king!= 1 or white_king!= 1:
        return False
    if black_pieces > 16 or white_pieces > 16:
        return False
    if black_pawns > 8 or white_pawns > 8:
        return False

    return True

# 測試
board = {'h1': 'bK', 'c6': 'wQ', 'g2': 'bB', 'h5': 'bQ', 'e3': 'wK'}
print(isValidChessBoard(board))  # True

board = {'h1': 'bK', 'c6': 'wQ', 'g2': 'bB', 'h5': 'bQ'}
print(isValidChessBoard(board))  # False

Fantasy Game Inventory

程式碼

def display_inventory(inventory):
    print("Inventory:")
    item_total = 0
    for k, v in inventory.items():
        print(f"{v} {k}")
        item_total += v
    print(f"Total number of items: {item_total}")

# 測試
stuff = {'rope': 1, 'torch': 6, 'gold coin': 42, 'dagger': 1, 'arrow': 12}
display_inventory(stuff)

輸出

Inventory:
1 rope
6 torch
42 gold coin
1 dagger
12 arrow
Total number of items: 62

List-to-Dictionary Loot Conversion

程式碼

def add_to_inventory(inventory, added_items):
    for item in added_items:
        if item in inventory:
            inventory[item] += 1
        else:
            inventory[item] = 1
    return inventory

# 測試
dragon_loot = ['gold coin', 'gold coin', 'gold coin', 'rope', 'torch']
stuff = {'rope': 1, 'torch': 6, 'gold coin': 42, 'dagger': 1, 'arrow': 12}
print(add_to_inventory(stuff, dragon_loot))

輸出

{'rope': 2, 'torch': 7, 'gold coin': 45, 'dagger': 1, 'arrow': 12}

字串與文字編輯

文字是程式最常處理的資料形式之一。您已經知道如何使用 + 運算元來串接兩個字串值，但您可以做更多的事情，例如從字串值中提取部分字串、新增或移除空白字元、將字母轉換為小寫或大寫，甚至檢查字串是否格式正確。您甚至可以撰寫 Python 程式碼來存取用於複製和貼上的剪貼簿。

字串操作

Python 提供了許多方法來操作字串。以下是一些例子：

串接：使用 + 運算元來串接兩個字串。
重複：使用 * 運算元來重複一個字串。
索引：使用方括號 [] 來存取字串中的特定字元。
切片：使用方括號 [] 來提取字串中的特定部分。

例子

# 串接
name = "John"
greeting = "Hello, " + name
print(greeting)  # 輸出: Hello, John

# 重複
word = "hello"
repeated_word = word * 3
print(repeated_word)  # 輸出: hellohellohello

# 索引
word = "hello"
print(word[0])  # 輸出: h

# 切片
word = "hello"
print(word[1:3])  # 輸出: el

清單與字串

清單可以包含多個相同的專案。以下是一個例子：

dragon_loot = ['gold coin', 'dagger', 'gold coin']

要將清單中的專案新增到庫存中，可以使用以下函式：

def add_to_inventory(inventory, added_items):
    for item in added_items:
        if item in inventory:
            inventory[item] += 1
        else:
            inventory[item] = 1
    return inventory

inv = {'gold coin': 42, 'rope': 1}
dragon_loot = ['gold coin', 'dagger', 'gold coin']
inv = add_to_inventory(inv, dragon_loot)
print(inv)  # 輸出: {'gold coin': 44, 'rope': 1, 'dagger': 1}

內容解密：

上述程式碼定義了一個函式 add_to_inventory()，該函式接受兩個引數：inventory 和 added_items。它遍歷 added_items 清單中的每個專案，如果該專案已經在 inventory 中，則增加其計數；否則，將其新增到 inventory 中並設定其計數為 1。最後，傳回更新的 inventory。

圖表翻譯：

上述流程圖描述了 add_to_inventory() 函式的執行流程。它從開始遍歷 added_items 清單中的每個專案，然後檢查該專案是否已經在 inventory 中。如果是，則增加其計數；否則，將其新增到 inventory 中並設定其計數為 1。最後，傳回更新的 inventory。

字串字面值

在 Python 中，字串值儲存在程式的記憶體中，而出現在程式碼中的字串值被稱為字串字面值。寫入字串字面值看似簡單：它們以單引號或雙引號開頭和結尾，中間包含字串值的內容。但是，如果你需要在字串中使用引號該怎麼辦？直接輸入 'That is Alice's cat.' 並不會奏效，因為 Python 會認為字串在 Alice 之後結束，並將剩餘的部分 (s cat.') 視為無效的 Python 程式碼。幸運的是，有多種方法可以寫入字串字面值。

雙引號

字串字面值也可以以雙引號開頭和結尾。使用雙引號的一個好處是，字串可以包含單引號字元。例如，輸入以下程式碼：

spam = "That is Alice's cat."

由於字串以雙引號開頭，Python 知道單引號是字串的一部分，而不是標誌著字串的結尾。然而，如果你需要在字串中使用單引號和雙引號，你將需要使用跳脫字元。

跳脫字元

跳脫字元允許你使用在字串字面值中其他情況下不可能包含的字元。跳脫字元由反斜線 (\) 後跟一個字元組成。例如，\' 是單引號的跳脫字元，而 \n 是換行字元的跳脫字元。你可以在以單引號開頭和結尾的字串中使用這種語法。要檢視跳脫字元的工作原理，請輸入以下程式碼：

spam = 'Say hi to Bob\'s mother.'

Python 知道，由於 Bob\'s 中的單引號後面有一個反斜線，所以它不是用於結束字串值的單引號。跳脫字元 \' 和 \" 分別允許你在字串中包含單引號和雙引號。

原始字串

你可以在字串字面值的開頭新增 r 使其成為原始字串字面值。原始字串使得輸入包含反斜線的字串值更加容易。例如，輸入以下程式碼：

print("Hello there!\nHow are you?\nI\'m doing fine.")

由於這是一個原始字串，Python 將反斜線視為字串的一部分，而不是跳脫字元的開始。

多行字串

雖然你可以使用 \n 跳脫字元將換行插入字串，但使用多行字串通常更容易。Python 中的多行字串以三個單引號或三個雙引號開頭和結尾。三個引號之間的任何引號、製表符或換行符都被視為字串的一部分。Python 的縮排規則不適用於多行字串中的行。

索引和切片

字串使用索引和切片，就像列表一樣。你可以將 'Hello, world!' 字串視為一個列表，其中每個字元都是具有相應索引和負索引的專案。

' H e l l o, w o r l d! '

內容解密：

上述程式碼展示瞭如何使用索引和切片來存取和操作字串中的個別字元。這種技術在需要對個別字元進行操作時非常有用，例如當你需要檢查特定位置的字元時。

圖表翻譯：

@startuml
skinparam backgroundColor #FEFEFE
skinparam componentStyle rectangle

title Python 字典與字串操作技術

package "資料視覺化流程" {
    package "資料準備" {
        component [資料載入] as load
        component [資料清洗] as clean
        component [資料轉換] as transform
    }

    package "圖表類型" {
        component [折線圖 Line] as line
        component [長條圖 Bar] as bar
        component [散佈圖 Scatter] as scatter
        component [熱力圖 Heatmap] as heatmap
    }

    package "美化輸出" {
        component [樣式設定] as style
        component [標籤註解] as label
        component [匯出儲存] as export
    }
}

load --> clean --> transform
transform --> line
transform --> bar
transform --> scatter
transform --> heatmap
line --> style --> export
bar --> label --> export

note right of scatter
  探索變數關係
  發現異常值
end note

@enduml

這個流程圖展示瞭如何使用索引和切片來存取和操作個別字元的過程。首先，你輸入一個字串，然後使用索引或切片來存取或操作個別字元，最後傳回結果。

字串操作入門

在 Python 中，字串是一種基本的資料型別，允許我們儲存和操作文字資料。在本文中，我們將探討如何使用 Python 進行字串操作。

字串索引

Python 中的字串是可索引的，這意味著我們可以使用索引值來存取字串中的特定字元。索引值從 0 開始，表示字串中的第一個字元。例如：

greeting = 'Hello, world!'
print(greeting[0])  # 輸出：H
print(greeting[4])  # 輸出：o
print(greeting[-1])  # 輸出：!

如您所見，我們可以使用索引值來存取字串中的特定字元。

字串切片

除了使用索引值存取單個字元外，我們還可以使用切片來存取字串中的子串。切片的語法為 string[start:end]，其中 start 是子串的起始索引，end 是子串的結束索引。例如：

greeting = 'Hello, world!'
print(greeting[0:5])  # 輸出：Hello
print(greeting[:5])  # 輸出：Hello
print(greeting[7:-1])  # 輸出：world
print(greeting[7:])  # 輸出：world!

注意，當我們省略 start 或 end 時，Python 會自動填充缺失的值。例如，greeting[:5] 等同於 greeting[0:5]。

切片不會修改原始字串

需要注意的是，切片不會修改原始字串。相反，它會傳回一個新的字串，包含了所需的子串。例如：

greeting = 'Hello, world!'
greeting_slice = greeting[0:5]
print(greeting_slice)  # 輸出：Hello
print(greeting)  # 輸出：Hello, world!

如您所見，原始字串 greeting 仍然保持不變。

字串操作與F-Strings

在Python中，字串是一種基本的資料型態，讓我們可以儲存和操作文字。瞭解如何操作字串是任何程式設計師的必備技能。

字串內容檢查

你可以使用in和not in運算元來檢查一個字串是否包含另一個字串。這些運算元會回傳一個布林值（True或False），表示是否找到匹配的內容。

print('Hello' in 'Hello, World')  # True
print('Hello' in 'Hello')  # True
print('HELLO' in 'Hello, World')  # False
print('' in 'spam')  # True
print('cats' not in 'cats and dogs')  # False

F-Strings

F-Strings是一種方便的方式，可以將變數或表示式嵌入到字串中。它們是在Python 3.6中引入的，使用方法是在字串前加上f字首。

name = 'Al'
age = 4000

print(f'My name is {name}. I am {age} years old.')  # My name is Al. I am 4000 years old.
print(f'In ten years I will be {age + 10}')  # In ten years I will be 4010

在F-Strings中，你可以使用大括號{}來包圍變數或表示式。這些內容會被自動轉換為字串並嵌入到主字串中。如果你需要在F-String中使用大括號本身，可以使用雙大括號{{}}。

F-String的替代方法

在Python 3.6之前，沒有F-Strings這個功能。因此，舊的Python程式可能會使用其他方法來實作類別似的功能，例如使用 %s 格式指定符或 format() 方法。

name = 'Zophie'
print(f'{name}')  # Zophie
print(f'{{name}}')  # {name}

字串處理和方法

在 Python 中，字串是一種基本的資料型態，允許您儲存和操作文字資料。以下是幾種常見的字串處理方法。

字串插值

字串插值是一種在字串中插入變數或其他字串的方法。Python 提供了三種字串插值方法： % 運算元、 format() 方法和 f-字串。

`%` 運算元

% 運算元是一種簡單的字串插值方法。您可以在字串中使用 %s 來標記插入變數的位置，然後使用 % 運算元將變數插入字串中。

name = 'Al'
age = 4000
print('My name is %s. I am %s years old.' % (name, age))

`format()` 方法

format() 方法是一種更強大的字串插值方法。您可以在字串中使用 {} 來標記插入變數的位置，然後使用 format() 方法將變數插入字串中。

name = 'Al'
age = 4000
print('My name is {}. I am {} years old.'.format(name, age))

f-字串

f-字串是一種新的字串插值方法，從 Python 3.6 版本開始提供。您可以在字串前面加上 f 來標記它是一個 f-字串，然後在字串中使用 {} 來標記插入變數的位置。

name = 'Al'
age = 4000
print(f'My name is {name}. I am {age} years old.')

字串方法

Python 提供了許多有用的字串方法，可以幫助您分析和轉換字串。以下是幾個常見的字串方法：

`upper()` 和 `lower()` 方法

upper() 和 lower() 方法可以將字串轉換為大寫或小寫。

spam = 'Hello, world!'
print(spam.upper())  # 輸出：HELLO, WORLD!
print(spam.lower())  # 輸出：hello, world!

`isupper()` 和 `islower()` 方法

isupper() 和 islower() 方法可以檢查字串是否全部為大寫或小寫。

spam = 'Hello, world!'
print(spam.isupper())  # 輸出：False
print(spam.islower())  # 輸出：False

案例研究

以下是一個簡單的案例研究，示範如何使用字串方法來處理使用者輸入：

print('How are you?')
feeling = input()
if feeling.lower() == 'great':
    print('I feel great too.')
else:
    print('I hope the rest of your day is good.')

在這個案例中，我們使用 lower() 方法將使用者輸入的字串轉換為小寫，然後進行比較。如果使用者輸入的字串是 “great”（無論大小寫），我們就會輸出 “I feel great too."。否則，就會輸出 “I hope the rest of your day is good."。

字串方法的使用與練習

在 Python 中，字串（string）是一種基本的資料型態，提供了許多有用的方法來操作字串。以下是幾個常用的字串方法：

大小寫轉換

upper(): 將字串全部轉換為大寫。
lower(): 將字串全部轉換為小寫。
isupper(): 檢查字串是否全部為大寫。
islower(): 檢查字串是否全部為小寫。

方法練習

# 測試 upper() 和 lower() 方法
print('Hello'.upper())  # 輸出：HELLO
print('Hello'.lower())  # 輸出：hello

# 測試 isupper() 和 islower() 方法
print('HELLO'.isupper())  # 輸出：True
print('hello'.islower())  # 輸出：True
print('Hello'.isupper())  # 輸出：False
print('Hello'.islower())  # 輸出：False

# 測試方法鏈式呼叫
print('Hello'.upper().lower())  # 輸出：hello
print('Hello'.upper().lower().upper())  # 輸出：HELLO

方法鏈式呼叫

字串方法可以鏈式呼叫，這意味著你可以在一個字串方法呼叫後面直接呼叫另一個字串方法。這樣可以簡化程式碼，提高可讀性。

例如，'Hello'.upper().lower() 等於先將 'Hello' 轉換為大寫，然後再轉換為小寫，最終得到 'hello'。

從底層實作到高階應用的全面檢視顯示，有效率地運用Python內建的資料結構和字串操作方法，能大幅簡化程式碼並提升程式效能。本文深入探討了字典、列表、字串等核心資料結構的特性，並示範如何結合迴圈、條件判斷等流程控制技巧，實作如西洋棋盤顯示、物品庫存管理、字串格式驗證等功能。透過分析不同資料結構的適用場景和操作方法，開發者能更有效地組織和處理資料，避免不必要的效能瓶頸。技術堆疊的各層級協同運作中體現，Python 的靈活性與豐富的內建函式庫，讓開發者能快速構建原型並實作複雜的功能。對於追求程式碼簡潔性和可維護性的開發者而言，深入理解並善用這些內建工具至關重要。玄貓認為，持續精進資料結構和演算法的應用能力，是Python開發者提升程式碼品質和效率的關鍵。

玄貓 BlackCat

技術愛好者，專注於分享程式開發、雲端技術與 AI 應用的心得體會。

Python 字典與字串操作技術

步驟 3：列印當前棋盤

實作 print_chessboard() 函式

示例使用

使用Python建立互動式西洋棋板

代表西洋棋板

顯示西洋棋板

切換方格顏色

格式化輸出

主程式

程式碼實作

內容解密：

圖表翻譯：

程式碼解析：國際象棋棋盤模擬器

程式流程圖

圖表翻譯

使用巢狀字典和列表儲存複雜資料

野餐嘉賓資料結構

計算總攜帶數量

結果

字典（Dictionary）概述

字典的基本結構

字典與列表的主要區別

存取字典值

檢查鍵是否存在

檢查值是否存在

快速新增鍵值對

美化字典輸出

練習題目

內容解密：

圖表翻譯：

Chess Dictionary Validator

程式碼

Fantasy Game Inventory

程式碼

輸出

List-to-Dictionary Loot Conversion

程式碼

輸出

字串與文字編輯

字串操作

例子

清單與字串

內容解密：

圖表翻譯：

圖表翻譯：

字串字面值

雙引號

跳脫字元

原始字串

多行字串

索引和切片

內容解密：

圖表翻譯：

字串操作入門

字串索引

字串切片

切片不會修改原始字串

字串操作與F-Strings

字串內容檢查

F-Strings

F-String的替代方法

字串處理和方法

字串插值

% 運算元

format() 方法

f-字串

字串方法

upper() 和 lower() 方法

isupper() 和 islower() 方法

案例研究

字串方法的使用與練習

大小寫轉換

方法練習

方法鏈式呼叫

玄貓 BlackCat

實作 `print_chessboard()` 函式

`%` 運算元

`format()` 方法

`upper()` 和 `lower()` 方法

`isupper()` 和 `islower()` 方法