# <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