---
# System prepended metadata

title: Python Note

---

# <span>Python Note</span>
> ### **基本指令**
---

* **輸入**
    `a = input()` *此輸入型態一率為 char*
    1. 轉型 
    `型態(input())`
    ex.
    `a_int = int(input())` *⭢ 輸入型態由char轉 int*
    2. 連續輸入 
    * `list(input().strip())`
    ex.
    `a_list = '123'`
    `a_list = list(input().strip())` *⭢ a_list = ['1', '2', ...]*
    
    * `[input().spilt()]`
    多加[]，型態會變成二元陣列 *⭢ a_list = [['1', '2', ...], ...]*
    * `map(型態, input().split())`
    ex.
    `a, b = map(int, input().split())` *⭢ a, b個別傳入值，型態為int*
    3. 同一行分別輸入 加入list
    `enter = list(input())`
    *⭢ 輸入為'a' 'b' 'c'，enter = ['a', 'b', 'c']*
    
* **輸出**
    1. 一般文字 
    `print("文字內容")`
    ex.
    `print("Hello.")`  *⭢ 輸出：Hello.*
    2. 包含參數
    `print(f"文字內容{參數}文字內容")`
    3. 依序列出陣列內容
    `for 參數 in 陣列:`
    `print(參數, end = " ")` 
    ex.
    `list_num = [1, 2, 3]`
    `for num in list_num:`
    ` print(num, end = " ")` *⭢ 輸出：1 2 3*
    4. 浮點數印出
        * 有四捨五入
    `round(參數, 浮點數第幾位)` *⭢ 多的浮點數取一部分*
    ex.
    `print(f"{round(3.14159, 3)}")`
    *⭢ 輸出：3.141*
    or
    `"{:.浮點數第幾位f}".format(參數)` *⭢ 設浮點數取到第幾位 注意會四捨五入*
    ex.
            ```
            a = 1.0
            print("{:.3f}".format(a))
            ```
        *⭢ 輸出：1.000*
        * 無四捨五入
        `字串參數[:字串參數.index('.') + 要取幾個數字] `
        ex.
            ```
            a = 3.14515
            a_str = str(a)
            result = a_str[:a_str.index('.') + 3]
            print(result)  # 輸出: 3.14
            ```
* **list**
    1. int轉成list     
    * 從頭排序 *ex. a = 3, list_a = [1, 2, 3]*
    `a_list = list(range(1, a + 1))`
    * 一般int轉list
    `list = [int(digit) for digit in str(參數)]`
    ex.
        ```
        a = 245
        a_list = [int(digit) for digit in str(a)]
        print(a_list)  
        ```
        *⭢ 輸出：[2, 4, 5]*
    2. 建立有範圍的list
    ex.
    `list = [i for i in range(128)]` *⭢ list = [0, 1, ..., 127]*
    3. 反轉
    `list.reverse()`
    4. 值都一樣的list
    * ⭢ [值]*陣列長度 
    **注意！這樣以後做更動的話會整個陣列一起變動 無法單獨改變**
    ex.
        ```
        a = [0] * 5
        print(a)  
        ```
        *⭢ 輸出：[0, 0, 0, 0, 0]*   
    * [值 for _ in range(陣列長度)]
    ex.
    `a = [0 for _ in range(n)]`
    * 新增元素至任意位置
    `list.insert(想放入位置, 值)`
    ex.
        ```
        my_list = [2, 3, 4]
        my_list.insert(0, 1)  # 在第零項插入元素 1
        ```
        *⭢ my_list = [1, 2, 3, 4]*
* **多維list** 
    * 設定項次內容
    ex.
    `list_2d = [[sublist, 0] for sublist in list_2d]`
    *⭢ list_2d[sublist][1] 皆為0*
    * 項次內容改變
    ex.
    `list_2d = [[sublist, sublist[1] + 1] for sublist in list_2d]`
    *⭢ list_2d[sublist][1] 皆+1 變成皆為1*
    * 排序
    `list.sort(key = lambda 變數: key值)`
    ex.
        ```
        a = [['a', 1], ['c', 2], ['b', 3]]
        a.sort(key=lambda x: x[0]) #指定sort要看子序列第一個元素
        ```
        *⭢ a = [['a', 1], ['b', 3], ['c', 2]]*
    * enumerate
    ⭢ 用於迭代序列時跟蹤索引
    ex.
        ```
        # 列舉列表中的元素及其索引
        my_list = ['蘋果', '香蕉', '櫻桃']
        for index, fruit in enumerate(my_list):
        print(index, fruit)

        # 列舉字符串中的字符及其索引
        my_string = 'hi'
        for index, char in enumerate(my_string):
        print(index, char)

        # 指定起始索引值為 1
        for index, fruit in enumerate(my_list, start=1):
        print(index, fruit)
        ```
        *⭢ 輸出 : 
        0 蘋果
        1 香蕉
        2 櫻桃
        0 h
        1 i
        1 蘋果
        2 香蕉
        3 櫻桃*

    * 新增
    `list = [1, 2, 3]`
    `list_1.append(list)` *⭢ list_1 = [[1, 2, 3]] 為二維陣列* 
    `list_2.extend(list)` *⭢ list_2 = [1, 2, 3] 為一維陣列*
* **迴圈**
    * 有區間範圍
    `for i in range(min, max):` *⭢ 範圍從 min 到 max - 1*
    * 只要固定值進入迴圈
    `for i in(a, b):` *⭢只有 a, b 會進入迴圈*
* **其它**
    * 進位轉換
    `int(數字)` *⭢ 十進位*
    `bin(數字)` *⭢ 二進位*
    `oct(數字)` *⭢ 八進位*
    `hex(數字)` *⭢ 十六進位*
    * 進位運算
    只能先轉十進位運算在轉成其它進位
    * 進位輸入
    `a = input()` *⭢ 原 a 為str*
    `bin_a = int(a, 2)` *⭢ int(參數, 幾進位) ： 轉十進位*
    * 進位輸出
    `print(bin(8))` *⭢ 輸出：0b1000 *
        `a = bin(8)[2:]` 
        `print(a)` *⭢ 移除前綴，輸出：1000*
    * ASCII code轉換
    `ord()`
    ex.
        ```
        text = "Hello"
        ascii_values = [ord(char) for char in text]
        print(ascii_values)
        ```
        *⭢ 輸出：[72, 101, 108, 108, 111]*
    
    * 排序
    `sorted()` ⭢ 對列表進行排序，不修改原始列表
    ex. 
        ```
        my_list = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
        sorted_list = sorted(my_list) 
        print("Sorted list:", sorted_list)
        print("Original list:", my_list)  # 原始列表保持不變
        ```
        `sort()` ⭢ 直接修改原始列表
        ex.
        ```
        my_list.sort()
        print("Sorted list:", my_list)  # 原始列表已經被修改
        ```
    * 倒序
    [::-1]
    ex.
        ```
        a = "apple"
        a_reverse = a[::-1]
        ```
        *⭢ a_reverse = "elppa"*
    
    * 非a則b
    `a if condition else b` *⭢ 等同於 condition ? a : b*
    ex.
    `result = 'even' if x % 2 == 0 else 'odd'`
    *⭢ 不是偶數則為奇數*
    
    * 刪除
        * pop()
        ⭢ 僅從列表中刪除並返回**最後一個元素**
        ex.
            ```
            list = [1, 2, 3]
            target = list.pop() 
            # list = [1, 2]
            # target = 3
            ```
        * del & remove()
        ⭢ 刪除列表中特定元素
        ex.
            ```
            nums = [2, 7, 11, 15]
            nums.remove(11)  # nums = [2, 7, 15]
            del nums[2] # nums = [2, 7]
            ```

* **math**
    * log
    ex.
    `log_base_2 = math.log(8, 2)`
    *⭢ 輸出：3
* **def**
    ⭢ 定義函數的關鍵詞
    ex.
    ```
    def is_prime(n):
        if n <= 1:
            return False
        for i in range(2, int(n**0.5) + 1):
            if n % i == 0:
                return False
        return True
    ```
    *⭢ 設定判斷是否為質數的函數*
* **join()**
    ⭢ 將字元或字串串聯在一起
    ex.
        ```
        words = ["Hello", "world", "Python"]
        sentence = ' '.join(words)
        print(sentence)
        ``` 
        *⭢ 輸出：Hello world Python*    
    ex.
        ```
        a_list = ['1', '2', '3']
        a = "".join(map(str, a_list)) #為了轉成字串才加map
        ```
        *⭢ a = '123'*
 * **lambda** *(超好用...*
     * 排序 & sort / sorted
     ex.
         ```
        words = ["apple", "banana", "orange", "grape"]
        sorted_words = sorted(words, key=lambda x: len(x))
        print(sorted_words)  # 輸出：['apple', 'grape', 'banana', 'orange']
        ```
    * 過濾 & filter
    ex.
        ```
        numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
        even_numbers = filter(lambda x: x % 2 == 0, numbers)
        print(list(even_numbers))  # 輸出：[2, 4, 6, 8, 10]
        ```
    * 整體調整 & map
    ex.
        ```
        numbers = [1, 2, 3, 4, 5]
        doubled_numbers = map(lambda x: x * 2, numbers)
        print(list(doubled_numbers))  # 輸出：[2, 4, 6, 8, 10]
        ```
* **zip()**
    ⭢ 將多個可迭代對象進行組合，返回一個由 tuple 構成的迭代器
    ex.
    ```
    list1 = [1, 2, 3]
    list2 = ['a', 'b', 'c']
    list3 = ['x', 'y', 'z']
    zipped = zip(list1, list2, list3)
    ```
    *⭢ (1, 'a', 'x'), (2, 'b', 'y'), (3, 'c', 'z')*   
<span>
</span>
> ### **標準庫**
---     
* **math**
    * 最大公因數 & 最小公倍數
        `math.gcd(a, b)` *⭢ 最大公因數*
         `lcm = (a * b) // math.gcd(a, b)` *⭢ 最小公倍數 ( python只有gcd*
         
* **re**
    * findall
    