判斷閏年

初始版本

year = input('請輸入一個年份：')

while not year.isdigit():
    year = input("抱歉，您的輸入有誤，請輸入一個整數：")

year = int(year)
if year % 400 == 0:
    print(year, "是閏年！")
else:
    if year % 4 == 0 and year % 100 != 0:
        print(year, "是閏年！")
    else:
        print(year, "不是閏年！")

isdigit()函式

isdigit() 是 Python 字串物件的方法，用于判斷字串是否只包含數字字符，該方法回傳一個布林值，如果字串中所有字符都是數字，則回傳 True，否則回傳 False，如果字串為空，則回傳 False，

my_string = "12345"
print(my_string.isdigit()) # 輸出 True

my_string = "123abc"
print(my_string.isdigit()) # 輸出 False

my_string = ""
print(my_string.isdigit()) # 輸出 False

在實際編程中，可以使用 isdigit() 來檢查輸入的是否是數字，以確保輸入的是有效資料，例如，在一個需要輸入數字的程式中，可以使用 isdigit() 來驗證用戶的輸入是否為數字，如果不是，則提示用戶重新輸入，

優化版本

將判斷閏年的邏輯封裝到一個函式中，這樣使得程式結構更加清晰，另外，對于輸入的例外處理，可以考慮添加一個回圈讓用戶在輸入錯誤時可以重新輸入，而不是只提示一次，這是一個修改后的版本：

def is_leap_year(year: int) -> bool:
    if year % 400 == 0 or (year % 4 == 0 and year % 100 != 0):
        return True
    return False


def get_year_input(prompt: str) -> int:
    while True:
        year = input(prompt)
        if year.isdigit():
            return int(year)
        else:
            print("抱歉，您的輸入有誤，請輸入一個正整數，")


def main():
    year = get_year_input("請輸入一個年份：")
    if is_leap_year(year):
        print(year, "是閏年！")
    else:
        print(year, "不是閏年！")


if __name__ == "__main__":
    main()

語法分析

def is_leap_year(year: int) -> bool

year: int 是一個型別提示注釋，用于告訴程式員和解釋器該函式的引數 year 應該是一個整數型別，
-> 的語法是一種函式注解（function annotation），它可以用來為函式的引數和回傳值添加一些元資料，比如型別、描述等，函式注解是可選的，它不會影響函式的執行，也不會強制型別檢查，它只是提供了一些額外的資訊，方便閱讀和理解代碼，你可以使用 __annotations__ 屬性來訪問函式的注解，例如：

# 定義一個帶有注解的函式
def is_leap_year(year: int) -> bool:
    if year % 400 == 0 or (year % 4 == 0 and year % 100 != 0):
        return True
    return False

# 查看函式的注解
print(is_leap_year.__annotations__)

輸出結果：

{'year': <class 'int'>, 'return': <class 'bool'>}

這個例子中，-> bool 表示這個函式的回傳值是一個布林值，year: int 表示這個函式的引數 year 是一個整數，這樣，其他人在閱讀或呼叫這個函式時，就可以清楚地知道這個函式的輸入和輸出型別，當然，你也可以使用其他型別或運算式作為注解，比如字串、串列、字典等，只要它們是合法的 python 運算式即可，你也可以使用 typing 模塊中的一些特殊型別來表示更復雜的型別，比如 Union、Optional、List 等，

Python 安裝互動式查詢程式

問題展現

Python 歷史上有幾個重要的版本節點：

January 1994，Python1.0 發布
2000年10月16日，Python2.0 發布
2010年7月3日，Python2.7 發布，這是Python2.x的最后一個版本，Python2.x 和 Python3.x不兼容
2008年12月3日，Python3.0 發布，Python3引入多個和Python2.x不兼容的特性，Python 從2.x到3.x的遷移經歷了比較長的時間，編程語言版本不兼容有時候會是個致命錯誤（例如Perl6），好在Python挺過來了，
2021年10月5號，Python3.10 發布，這是目前到2021年為止最新的版本
而最新的開發中版本是 Python3.11

不同平臺對Python環境的默認支持是不同的：

Windows 平臺沒有默認安裝 Python
Linux/Mac 平臺大部分默認安裝了 Python2.7

一般建議安裝Python3.x 版本進行學習或開發，下面的Python字典給出了不同平臺的安裝資訊：

install = {
    "Windows": "請下載 Windows 安裝包安裝：https://www.python.org/downloads/windows/",
    "CentOS": "使用yum包管理器，執行命令：yum install -y python3",
    "Ubuntu": "使用apt-get包管理器，執行命令：apt-get install -y python3",
    "MacOS": "安裝brew包管理器，然后執行命令： brew install python3",
}

基于這個資訊，我們可以撰寫一個互動式Python程式，要求支持用戶操作：

反復輸入平臺快捷鍵字符查詢不同平臺應該如何快速安裝 Python3.x 版本
按q退出查詢

if __name__ == '__main__':
    install = {
        "Windows": "請下載 Windows 安裝包安裝：https://www.python.org/downloads/windows/",
        "CentOS": "使用yum包管理器，執行命令：yum install -y python3",
        "Ubuntu": "使用apt-get包管理器，執行命令：apt-get install -y python3",
        "MacOS": "安裝brew包管理器，然后執行命令： brew install python3",
    }

    shortcut_keys = {}
    for platform in install:
        key = platform[0].lower()
        shortcut_keys[key] = platform
    
    # TODO(You): 請在此添加Python3.x安裝檔案互動式查詢代碼

以下是互動式執行的操作樣例:

請選擇安裝平臺[w/c/u/m, 按q退出]：w
Windows: 請下載 Windows 安裝包安裝：https://www.python.org/downloads/windows/
請選擇安裝平臺[w/c/u/m, 按q退出]：c
CentOS: 使用yum包管理器，執行命令：yum install -y python3
請選擇安裝平臺[w/c/u/m, 按q退出]：u
Ubuntu: 使用apt-get包管理器，執行命令：apt-get install -y python3
請選擇安裝平臺[w/c/u/m, 按q退出]：m
MacOS: 安裝brew包管理器，然后執行命令： brew install python3
請選擇安裝平臺[w/c/u/m, 按q退出]：q

解決方案

方案 1

while True:
    ret = input("請選擇安裝平臺[w/c/u/m, 按q退出]：")
    if ret != 'q':
        platform = shortcut_keys.get(ret)
        if platform is not None:
            doc = install.get(platform)
            print(f"{platform}: {doc}")
        else:
            print("不支持的平臺")
    else:
        break

方案 2

while True:
    ret = input("請選擇安裝平臺[w/c/u/m, 按q退出]：")
    platform = shortcut_keys.get(ret)

    if ret == 'q':
        break
    
    if platform is None:
        print("不支持的平臺")
        continue
    
    doc = install.get(platform)
    print(f"{platform}: {doc}")

方案 3

while True:
    ret = input("請選擇安裝平臺[w/c/u/m, 按q退出]：")
    if ret == 'q':
        break
    platform = shortcut_keys.get(ret)
    if platform is None:
        print("不支持的平臺")
    else:
        doc = install.get(platform)
        print(f"{platform}: {doc}")

重點語法分析

shortcut_keys = {}
for platform in install:
    key = platform[0].lower()
    shortcut_keys[key] = platform

shortcut_keys = {platform[0].lower(): platform for platform in install}

兩段代碼的目的都是根據 install 字典創建一個新的 shortcut_keys 字典，鍵是平臺名字的首字母的小寫形式，值是完整的平臺名字，

第一段代碼：使用了一個 for 回圈來遍歷 install 字典的鍵（即平臺名字），對于每個平臺名字，它首先提取平臺名字的第一個字符（platform[0]），然后將其轉換為小寫形式（platform[0].lower()），并將其作為新字典 shortcut_keys 的鍵，接著，它將完整的平臺名字作為鍵對應的值，這樣，我們就得到了一個與 install 字典具有相同值但鍵不同的新字典，
在這一段 python 陳述句中，shortcut_keys = {} 用的是大括號{}，是因為 shortcut_keys 是一個字典(dictionary)，字典是一種用來存盤鍵值對(key-value pairs)的資料結構，它們用大括號{}來表示，字典的鍵(key)可以是任何不可變的型別，比如字串、數字或元組，而值(value)可以是任何型別，比如串列、函式或物件，字典的元素可以通過鍵來訪問，而不是通過索引(index)，例如，shortcut_keys[‘i’] 會回傳 install 這個值，

第二段代碼：這段代碼使用了字典推導（dictionary comprehension），它是一種更簡潔的創建字典的方法，字典推導的語法類似于串列推導，但使用大括號 {}（而不是方括號 []），并在其內部包含鍵值對（而不是單個元素），
字典推導的基本結構是：{key_expression: value_expression for item in iterable}
在這個例子中，key_expression 是 platform[0].lower()，value_expression 是 platform，iterable 是 install，這個字典推導的含義是：對于 install 字典的每個鍵（即平臺名字 platform），創建一個鍵值對，鍵是 platform[0].lower()，值是 platform，這樣，我們得到了與第一段代碼相同的結果，

優化結果

if __name__ == '__main__':
    install = {
        "Windows": "請下載 Windows 安裝包安裝：https://www.python.org/downloads/windows/",
        "CentOS": "使用yum包管理器，執行命令：yum install -y python3",
        "Ubuntu": "使用apt-get包管理器，執行命令：apt-get install -y python3",
        "MacOS": "安裝brew包管理器，然后執行命令： brew install python3",
    }

    shortcut_keys = {platform[0].lower(): platform for platform in install}

    while True:
        platform_input = input("請選擇安裝平臺[w/c/u/m, 按q退出]：")
        if platform_input.lower() == 'q':
            break

        platform = shortcut_keys.get(platform_input.lower())
        if platform:
            print(f"{platform}: {install[platform]}")
        else:
            print("輸入有誤，請重新輸入，")

可以考慮將用戶輸入和指令顯示的功能封裝到函式中，以提高代碼的可讀性，

def display_install_instructions(install_dict, shortcut_keys):
    while True:
        platform_input = input("請選擇安裝平臺[w/c/u/m, 按q退出]：")
        if platform_input.lower() == 'q':
            break

        platform = shortcut_keys.get(platform_input.lower())
        if platform:
            print(f"{platform}: {install_dict[platform]}")
        else:
            print("輸入有誤，請重新輸入，")


if __name__ == "__main__":
    install = {
        "Windows": "請下載 Windows 安裝包安裝：https://www.python.org/downloads/windows/",
        "CentOS": "使用yum包管理器，執行命令：yum install -y python3",
        "Ubuntu": "使用apt-get包管理器，執行命令：apt-get install -y python3",
        "MacOS": "安裝brew包管理器，然后執行命令： brew install python3",
    }

    shortcut_keys = {platform[0].lower(): platform for platform in install}
    display_install_instructions(install, shortcut_keys)

字典和串列

字典（dictionary）和串列（list）都是 Python 中常用的資料結構，但它們之間存在一些關鍵的區別：

鍵值對 vs. 有序元素集合：
- 字典是一個基于鍵值對（key-value pair）的無序集合，在字典中，每個元素都有一個唯一的鍵（key）與之對應，字典中的元素通過鍵來訪問，而不是通過索引，
- 串列是一個有序的元素集合，串列中的元素可以通過索引訪問，索引從 0 開始，按元素在串列中的順序遞增，
可變性：
- 字典和串列都是可變的（mutable），這意味著它們的內容可以在運行時修改，
查找速度：
- 字典使用散列（hashing）技術，因此在查找特定鍵時，字典的查找速度通常非常快，字典的查找速度與字典的大小無關，
- 串列查找元素的速度通常較慢，尤其是在大型串列中，串列的查找速度取決于串列的大小，
語法：
- 字典使用大括號 {} 來創建，每個元素由鍵和值組成，鍵值對之間用冒號 : 分隔，元素之間用逗號 , 分隔，例如：{'key1': 'value1', 'key2': 'value2'}，
- 串列使用方括號 [] 來創建，元素之間用逗號 , 分隔，例如：[1, 2, 3, 4]，

常用的串列（list）和字典（dictionary）的操作方法：

串列（list）操作

創建串列：
my_list = [1, 2, 3, 4]
訪問串列元素：
first_element = my_list[0] second_element = my_list[1]
修改串列元素：
my_list[0] = 10 my_list[1] = 20
添加元素到串列末尾：
my_list.append(5)
在串列指定位置插入元素：
my_list.insert(1, 1.5)
從串列中洗掉元素（通過索引）：
del my_list[0]
從串列中洗掉元素（通過值）：
my_list.remove(2)
彈出串列中的最后一個元素：
last_element = my_list.pop()
彈出串列中的指定位置的元素：
second_element = my_list.pop(1)
串列切片（截取串列的一部分）：
sublist = my_list[1:3]
串列排序（從小到大）：
my_list.sort()
串列反轉：
my_list.reverse()
計算串列中元素的個數：
length = len(my_list)
計算串列中特定元素出現的次數：
count = my_list.count(2)
查找串列中特定元素的索引（如果元素不存在，會拋出例外）：
index = my_list.index(3)
串列拼接：
list1 = [1, 2, 3] list2 = [4, 5, 6] combined_list = list1 + list2
串列復制：
copied_list = my_list.copy()
清空串列：
my_list.clear()

字典（dictionary）操作

創建字典：
my_dict = {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}
訪問字典元素：
value1 = my_dict['key1']
value2 = my_dict['key2']
修改字典元素：
my_dict['key1'] = 'new_value1'
my_dict['key2'] = 'new_value2'
添加新的鍵值對到字典：
my_dict['key4'] = 'value4'
從字典中洗掉鍵值對：
del my_dict['key1']
檢查字典中是否存在某個鍵：
if 'key1' in my_dict: print("Key 'key1' exists in the dictionary.")
獲取字典中所有的鍵：
keys = my_dict.keys()
獲取字典中所有的值：
values = my_dict.values()
獲取字典中所有的鍵值對（元組形式）：
items = my_dict.items()
使用get()方法訪問字典元素（如果鍵不存在，回傳默認值）：
value1 = my_dict.get('key1', 'default_value')
使用 update() 方法將另一個字典的鍵值對合并到當前字典中（如果有重復的鍵，當前字典的值將被覆寫）：
another_dict = {'key5': 'value5', 'key6': 'value6'} my_dict.update(another_dict)
使用pop()方法洗掉并回傳字典中指定鍵的值（如果鍵不存在，回傳默認值或拋出例外）：
value3 = my_dict.pop('key3', 'default_value')
使用popitem()方法洗掉并回傳字典中最后一個鍵值對（如果字典為空，拋出例外）：
last_item = my_dict.popitem()
設定字典中指定鍵的默認值（如果鍵已經存在，則不修改其值）：
my_dict.setdefault('key1', 'default_value1')
清空字典：
my_dict.clear()

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/549971.html

標籤：其他

上一篇：Java：如何加密或解密PDF檔案？

下一篇：13檔案操作

Python程式筆記20230306