@@ 天池python 訓練營 Task 02

易忘知識點

1. 串列 – list【有序可修改】

創建
    1. x = [1, 2, 3]
    2. x= list(range(起始，終止， 步長))
    3. 推導式 -- x = [運算式 for i in range() if ]
    4. [a] * 3 只是創建3個指向list的參考，一旦a改變，x中的3個a也會改變
        a = [0] * 3
        x = [a] * 3
        x = [[0, 0, 0], [0, 0, 0], [0, 0, 0]]
添加
    末尾 -- append【當作一個整體放在末尾的第一個位置】/  extend 【所有東西依次添加在末尾后】
        x = ['11']
        x.append([22, 33]) -- x = ['11', [22, 33]]
        x.extend([22, 33]) -- x = ['11', 22, 33]
    隨即位置 -- insert(索引位置，值)
洗掉 
    pop(指定索引位置) -- 不填默認刪最后一個 -- 刪后還能用
    remove(指定洗掉的元素) -- 要填
    del x[起始洗掉：最后洗掉位置] -- 刪后即焚【沒了】
獲取
    1. x[起始 : 終止 : 步長] -- 【所有的起始終止都是左閉右開】
    2. 淺拷貝 -- y = x[:] -- 對x排序等操作不會影響y
    3. 深拷貝 -- y = x -- 對x的操作都會影響到y一起變
        如果 x = [[1, 2, 3], [4, 5, 6]]
        x[0][0] = 66
        深拷貝和淺拷貝都會變！！！
常用運算子
    1.  == 一模一樣為true
    2.  + 【拼接，相當于extend】【創建新list物件 消耗多余記憶體】【extend，append，insert 直接改變原陣列中】
    3. * 復制 -- [1, 2] * 3 = [1, 2, 1, 2, 1, 2]
    4. in/ not in -- 在里面/不在里面 -- 成員關系
其他方法
    list.count(obj) -- 某數出現的次數
    list.index(obj, 起始位置，終止位置) -- 某數出現的索引位置
    list.reverse() -- 反向串列中的元素
    sort (key = 函式) -- 根據函式的回傳值進行排序，比如是根據二維陣列的第二位進行排序

2. 元組 – tuple 【有序不可修改】

基本操作同串列 -- 只有一個元素要加逗號，否則會被認為整型等 -- 【（1，）】
    EG：
        1. 創建
            直接賦值
            tuple(range())
            推導式
            乘
        1. 1 創建二維元組
            x = (1, 2, 3), (4, 5, 6)
            print(x) -- ((1, 2, 3), (4, 5, 6))
        2. 沒有添加，洗掉
        2.1 更新和洗掉一個元組 -- 對元組內部的值進行操作
            1. 更新
                x = (1, 2, 3, 5)
                x1 = x(:2) + (4, ) + x(2: )
            2. 洗掉
                x = (1, 2, 3, [4, 5])
                x[3][0] = 6
        3.  獲取 -- x [起始，終止，步長]
        4. 常用運算子 -- ==， + ，*， in/ not in
        5. 其他方法 -- 由于不可變，只有 count和index
解壓
    一維陣列
        t = (1, 2, 3)
        (a, b, c) = t
        print(a, b, c)
    二維陣列
        t = (1, 2, 3, (4, 5))
        (a, b, c, (d, e)) = t
        print(a, b, c, (d, e))
通配符 -- 沒懂，見問題記錄！！

3. 字串

定義
    單引號/雙引號
    轉義符
        \\ -- \
        \' -- '
        \" -- "
        \n -- 換行
        \r -- 回車
        \t -- 橫向制表符
    原始字串 -- r '內容'
    三引號 -- 多行字串， 換行符制表符等起作用
操作
    切片 同串列元組的獲取 -- x[起始 : 終止 : 步長]
    連接 +
內置方法
    capitalize() -- 字串第一個字母轉換成大寫,其他全小寫
    lower() -- 全小寫， upper() -- 全大寫， swapcase() -- 大寫變小寫，小寫變大寫
    count(查找的字符， 起始位置，終止位置) -- 查找出現的次數
    startswith(某字符，beg, end) -- 查找是否以該字符開頭
        endswith(某字符， beg, end) -- 查找是否以該字符結尾
    find(某字符，beg, end) -- 查找是否在字串內以及在的位置
        rfind(某字符，beg, end) -- 從右往左找，回傳的還是正數的索引位置
    isnumeric() -- 是否全部由數字組成
    ljust(寬度， 填充字符) - 左對齊，不足該寬度的用填充字符填充 
        rjust -- 右對齊，同上
    strip(字符) -- 左右均截掉該字符
        lstrip() -- 左側截掉該字符
        rstrip() -- 右側截掉該字符
    partition(字符) -- 找到該字符將字串切割成三份
        rpartition(字符) -- 從右開找
    replace(之前的字符，新的字符，最大替換的次數）
    split(分割的字符， 分割的次數)
    splitlines(True) -- 按 \r, \n, \r\n, 為True會留下\n, \r, \r\n
    maketrans(需要轉換的字符， 轉換的字符目標)
    translate(table)-- 根據這個table表來轉換字符
格式化
    格式化函式 -- 字串中大括號，后面format
        str1 = "{0} Danke {1}". format("蛋殼"， "真可愛")
    格式化符號
        %r -- 格式化字串，用rper()方法處理物件, 回傳值會帶引號
        %s -- 格式化字串，用str()方法處理物件， 回傳值只有值
    格式化運算子

4. 字典 – dict 【鍵+值】【無序可修改】

可變型別與不可變型別
    判斷方法
        1. id(x), 對x進行操作 看id是否變 -- 變【不可變型別】
        2. hash(x), hash不報錯 -- 【不可變型別】
    可變型別
        串列、集合、字典
    不可變型別
        字符、元組、數值
字典的定義
    查找插入速度極快，極占記憶體
創建和訪問字典
    dict1 = {鍵： 值}
    元組創建 --dict2 = {(1, 2, 3): 1, 4: [5, 6, 7]}
    dict創建1  -- dict3 = dict([(1, 2), (3, 4), (5, 6)]) / dict4 = dict(((1, 2), (3, 4), (5, 6))) -- 【輸出都是{1：2， 3: 4, 5: 6}】
    dict 創建2 -- dict5 = dict(name='Tom', age = 10) --【輸出是{name: Tom, age: 10}】【鍵必須是字串且不加引號】
字典的內置方法
    fromkeys -- 創建新字典
        dict7 = dict.fromkeys(('蛋殼'， '粉粉'，'太極')， (1, 2, 3)) -- {'蛋殼': ('1', '2', '3'), '粉粉': ('1', '2', '3'), '太極':('1', '2', '3')}
    取字典中的所有鍵 -- dict.keys() -- 轉換成串列 list(dict.keys())
    取字典中的所有值 -- dict.value() -- 轉換成串列 list(dict.values())
    取字典中的鍵值 串列元組陣列形式 - dict.items() -- 轉換成串列 list(dict.items())
    回傳指定鍵的值 -- dic1.get('鍵'， '找不到的默認值') -- 同 dic1.setdefault('鍵'， '找不到的默認值')
    key in/not in 字典 -- 判斷鍵是否在字典內
    pop(鍵， 找不到的默認值) -- 洗掉該鍵對應的值
    popitem() -- 隨即洗掉一對
    clear() -- 清空
    淺拷貝（copy()）VS 深拷貝 (賦值）
        修改值淺拷貝不變，有嵌套，嵌套值變淺拷貝會變
    dic1.update(dic2) -- dic2中的鍵值放到dic1中

5. 集合 – set【鍵】【無序不可修改】

集合的創建 
    1. set() + add (鍵)
    2.  =  {鍵1， 鍵2}
    3. set(其他型別) -- 用于去除重復值
訪問集合中的值
    長度 -- len()
    在不在里面 -- in / not in 
集合的內置方法
    1.  add -- 添加元素
    2.  update -- 復制到自己里面【洗掉重復元素】
    3. remove/ discard -- 洗掉某元素 【不在集合中discard不報錯】
    4. pop -- 隨機移除一個【我看到是第一個】
    集合操作
        5. 交集 -- 
            intersection(s1, s2) 
            s1 & s2 
             instersection_update(s1, s2)【使得原始集合上移除不重疊元素 改變原值】
        6.  并集 --
            union(s1, s2)
            s1  | s2
        7. 差集 -- 
            difference()
            s1 - s2
            difference_update(s1, s2) -- 參照交集
        8. 異或 --  s1中移除與s2中相同的元素，將s2中的不同元素插入
            s1.symmetric_difference(s2)
            s1 ^ s2
            s1.symmetric_difference_update(s2)
        9. 是否被其他集合包含
            s1.issubset(s2)
            s1 <= s2
        10. 是不是包含其他集合
            s1.issuperset(s2)
            s1 >= s2
        10. 是不是不相交 - 不相交 True / 相交 False
            s1.isdisjoint(s2)
    集合的轉換
        set() --將其他型別轉換成集合 
不可變集合
    frozenset() -- 凍結集合，不能做添加/洗掉操作【可進行集合操作，除帶有update的方法】

6. 序列

針對序列的內置函式
    1. list() -- 轉換成串列
    2. tuple() -- 轉換成元組
    3. str() -- 轉換成字串
    4. len() -- 回傳物件的長度
    5. max() -- 最大值
    6. min() -- 最小值
    7. sum(序列, 可選引數) --  序列，可選引數總和
    8. sorted(這個物件， key = 比較的元素， reverse =  True 降序 / False 升序) 
    9. reversed(序列) -- 反轉
    10. enumerate(序列，起始序列值)  -- 同時有資料和資料下標
    11. zip() -- 對應打包成元組
    12. zip(* 元組 ) -- 元組解壓成串列