今日內容

列表（list）：

  ======================================基本使用======================================
  1、用途:多個裝備，多個愛好，多門課程，多個女朋友等

  2、定義方式:：[]內可以有多個任意型別的值，逗號分隔   例：x = ["xxx","yyy",111]
     資料轉換方式：x = list("xxx")

  3、常用操作+內建的方法:
        優先掌握的操作：
        1、按索引存取值(正向存取+反向存取)：即可存也可以取     
              x = ["xxx","yyy",111]
              print(x[0]) 正向取    print(x[-1])   反向取
              ps:可以改變列表內索引對應的值，如果索引不在列表內也不能用變數來增加

        2、切片(顧頭不顧尾，步長)
              x[起始位置：結束位置：步長]      用法與字串一樣

        3、長度
              print(len(x))                      檢視列表內有多少個元素

        4、成員運算in和not in
              print("xxx" in x)                   判斷指定字串是否在列表中

        5、追加（append、insert)
              x.append(新增的值）                  總是在列表最後一位新增
              x.insert(索引，新增的值）             可以指定索引位置新增
  
        6、刪除（del、remove、pop）
              del x[索引]                          指定索引刪除，不指定索引會將整個列表刪除,索引不存在將報錯，無返回值
              x.remove("指定字串")                指定字串刪除，字串不在列表內將報錯，無返回值 
              x.pop(索引)                           指定索引刪除，不指定索引會刪除最後一位元素，索引不存在將報錯，有返回值

        7、迴圈（可配合for迴圈使用）
              for l in x:
                    print(l)                        會將列表中的每個元素取出來
        需要掌握的操作：
        1、拷貝（copy）
              new_x = x.copy()                      原理：new_x = x[:]          !：淺拷貝

        2、查詢（index）
              x.index(33)                            查詢括號內元素是否在列表中，不在會報錯

        3、統計指定元素的個數（count）
              print(x.count(33))                     計算列表中有幾個指定元素
  
        4、清空整個列表（clear）
              print(l.clear())                       清空整個列表，會留一個無值的空列表

        5、追加寫（extend）
              x.extend("hello")
              print(l)                               在原列表中追加寫一個可迭代（能被for迴圈）的元素

        6、倒序（reverse）
              x.reverse()
              print(x)                               將整個列表倒過來

        7、排序（sort）
              l = [11,-3,9,7,20,99,74]
              l.sort()
              print(l)                                從小到大排序
              l.sort(reverse=True)
              print(l)                                從大到小排序

  ======================================該型別總結====================================
  存多個值

  有序

  可變：值變，id不變。可變==不可hash
 

瞭解：深、淺拷貝

淺拷貝：只拷貝了第一層索引對應的記憶體地址，第一層中不可變型別改變，新舊列表之間不受影響

如果第一層中可變型別改變，新舊列表中的值會同時改變

深拷貝：拷貝了每一層的索引對應的記憶體地址，每一層中不可變型別改變，新舊列表之間不受影響

每一層中可變型別改變，新舊列表中的值不會同時改變

元祖（tuple）：

  ======================================基本使用======================================
  1、用途：存多個值，對比列表來說，元組不可變（是可以當做字典的key的），主要是用來讀

  2、定義方式：與列表型別比，只不過[]換成()
              age=(11,22,33,44,55)本質age=tuple((11,22,33,44,55))

  3、常用操作+內建的方法：
        優先掌握的操作：
        1、按索引取值(正向取+反向取)：只能取   
              print(x[0])                  可以按照索引取值

        2、切片(顧頭不顧尾，步長)：
              print(x[起始索引：結束索引：步長]

        3、長度
              print(len(x))                計算元組內有多少個元素

        4、成員運算in和not in
              print("xxx" in x)            判斷指定字串是否在元祖中

        5、迴圈（可配合for迴圈使用）
          
        需要掌握的操作：
        1、按索引查詢（index）
              print(x.index(11))           查詢指定元素在元祖中的索引，不存在則報錯

        2、統計指定元素的個數（count）
              print(x.count(22))           查詢指定元素在元祖中的個數
        ========================================================================
        x = (11,22,[33,44])
        x[0] = 22                          元祖內不可變元素值不能改變
        x[2][0] = 11
        print(x)                           元祖中可變元素，只能改變
        原理：元祖內都是索引和對應的記憶體地址，只要索引和記憶體地址不改變，值就可以改變
  ======================================該型別總結====================================
  存一個值

  有序

  不可變：值變，id就變。不可變==可hash
 

字典（dict）：

  ======================================基本使用======================================
  1、用途：存多個值,key-value存取，取值速度快

  2、定義方式：key必須是不可變型別，value可以是任意型別
              info={'name':'egon','age':18,'sex':'male'}      本質info=dict({....})
              或
              info=dict(name='egon',age=18,sex='male')
              或
              info=dict([['name','egon'],('age',18)])
              或
              {}.fromkeys(('name','age','sex'),None)


  3、常用操作+內建的方法：
        優先掌握的操作：
        1、按key存取值：可存可取：
              x = {"k1":111,"k2":222}
              print(x["k1"])                        按key來取值

              x["k3] = 333          
              print(x)                              如果key值不在字典內則增加一組，如果key值在字典中則改變字典中key對應的值

        2、長度len：
              len(x)                                計算字典中有多少組key:value

        3、成員運算in和not in
              print("k3" in x)                      判斷是否在字典內的key值中

        4、刪除
              del x["k1"]                           指定key值刪除所相對應的值
              res = x.pop("k1")                     指定key值刪除所相對應的值,有返回值
              res = x.popitem()                     隨機刪除字典內一組key,value值，有返回值

        5、鍵keys()，值values()，鍵值對items()
              x = {"k1":111,"k2":222}
              print(x.keys())                        顯示列表中所有key值
              print(x.values())                      顯示列表中所有values值
              print(x.items())                       顯示列表中所有key:values值

        6、迴圈
              可以被for迴圈使用
  ======================================該型別總結====================================
  存多個值

  無序

  key必須是不可變型別，value可以是任意型別