day06

列表的in / not in運算子
　　判斷一個值是否存在於列表中，如果存在返回True，否則返回False
  同字串的in 運算子
  用於檢查一個值是否存在與列表中，如果存在返回True，否則返回False

示例：
　　 x = [1, 'Two', 3, '四']
   3 in x  # 返回 True
  '3' in x  # 返回 False
   10 in x  # False
   10 not in x  # True 

列表的索引操作
　　語法：
　　　　列表[整數表示式]
　　用法：
　　　　與字串索引的用法相同（分為正向索引和反向索引）
　　示例：
　　　　x = [1,3,5,7]
    print(x[1])    # 3
    print(x[-1])   # 7

列表的索引賦值：
　　列表時可變的，可以通過索引賦值改變列表中的元素
　　語法：
　　　　列表[整數表示式]　＝　表示式
　　作用：
　　　　改變列表中索引的繫結關係
　　示例：
　　　　x = [1,2,3,4]
    x[2] =3.14    # 改變了第三個元素的值
　　　

列表的切片
　　列表[:]
  列表[::]
  列表的切片取值返回一個新的列表，規則等同於字串切片規則
  　
  示例：
  　　x = [1,2,3,4,5,6,7,8]
    x[::2]       #[1,3,5,7]
    y = [1::3]   #[2,5,8]

列表的切片賦值
　　作用：
　　　　可以改變元列表的資料排列，可以插入和修改資料
　　　　可以用切片改變列表對應元素的值
　　語法：
　　　　列表[切片]　＝　可迭代物件
　　說明：
　　　　切片賦值的賦值運算子（=）的右側必須是一個可迭代物件
　　　
　　示例：
   # 切片賦值可以增加或減少原來的資料元素
　　　l = [2,3,4]
   l[0:1] = [1.1,2.2]       # l = [1.1, 2.2, 3,4]
   l[2:]=[3.3,4.4,5.5]      # l = [1.1, 2.2, 3.3, 4.4, 5.5]
   l[:]=[3,4]               # l = [3, 4]
   
   #　在列表首部填加
   l = [3, 4]
   l[0:0]=[1,2]             # l = [1, 2, 3, 4]

   l = [3,4]
   l[1:1]=[3.14]            # l = [3, 3.14, 4]

　　　#　在列表尾部填加
　　　#　切片賦值支援索引越界(向後新增)
   l = [3,4]
   l[2:2]=[5, 6]
   l[-1:-1]=[5,6]           # l = [3, 4, 5, 6]
   
　　　# 切片賦值可以全部清空
   l = [3,4]
   l[::]=[]                 # l = []
   

   #字串為可迭代物件，進行依次取值
   l = [2, 3, 4]
   l[1:2]='ABC'             # l = [2, 'A', 'B', 'C', 4]
　　　
　　　#切片賦值可以取可迭代物件range
　　　l = [2, -1, 7]
   l[1:2]=range(3,7)        # l = [2,3,4,5,6,7]
   
切片的注意事項：
　　對於步長不等於１　的切片賦值，賦值運算子的右側的可迭代物件提供元素的   個數不一定要等於切片切出的段數
　　示例：
　　　　l = [1,2,3,4,5,6,7,8]
    l[1::2] = 'ABCD' # 對的 
                     # l = [1, 'A', 3, 'B', 5, 'C', 7, 'D']
    
    l[1::2] = 'ABCDE'       # 錯的  

del語句用來刪除列表的元素
    （對變數所繫結的列表進行操作）
　　語法：
　　　　del　列表[索引]
　　　　　　　　如：　del L[0]
    del 列表[切片]
    　　　　如：　del L[1::2]

練習一：
　　已知有列表：
　　　　l = [3,5]
  用索引和切片操作，將原列表改變為：
  　　l = [1,2,3,4,5,6]
  將列表反轉，刪除最後一個元素後列印此列表
  　....
    print(l)     #[6,5,4,3,2]

python 3中常用於序列的函式
  len(s)  返回序列的長度
  max(x)  返回序列的最大值元素
  min(x)  返回序列的最小值元素
  sum(x)  返回列中所有元素的和(元素必須是數值型別)
  any(x)  真值測試,如果列表中其中一個值為真值則返回True (與or相近)
  all(x)  真值測試,如果列表中所有值為真值返回True　　　　 (與and相近)

示例:
  L = [3, 1, 9, 7, 5]
  print(len(L))  # 5
  print(max(L))  # 9
  print(min(L))  # 1
  print(sum(L))  # 25

練習二：
　　寫程式，讓使用者迴圈輸入一些整數，當輸入-1時結束，
　　將這些整數存於列表l中
　　１）列印您共輸入了多少個有效的數？
　　２）列印您輸入的最大數是？
　　３）列印您輸入的最小數是？
　　４）列印您輸入的這些數的平均值是多少？

python3中常用的列表的放法：
　　詳見：>>>>help list
　　文件資料：list.html

   L.index(v [, begin[, end]])返回對應元素的索引下標
     l=[1,3,5,7]
     l.index(3)      #1

   l=[1,3,4,5,7,3,8,9]
     l.index(3)=1
     l.index(3,2)    #5
    
   L.insert(index, obj) 將某個元素插放到列表中指定的位置 
     l=[1,3,4,5,7,3,8,9]
     l.insert(2,2)     #l=[1,3,2,4,5,7,3,8,9]

   L.count(x) 返回列表中元素的個數 

   L.remove(x) 從列表中刪除第一次出現在列表中的值 
     l=[1,3,4,5,7,3,8,9]
     l.remove(3)      #l=[1,4,5,7,3,8,9]
    
   
   L.copy() 複製此列表（只複製一層，不會複製深層物件) 
     l=[1,3,4,5,7,3,8,9]
     l[2]=[1]
     l2=l
     #  非複製,為賦值

     l2=l.copy（）
     #  複製

   L.append(x) 向列表中追加單個元素
   　　l=[1,3,4,5,7,3,8,9]
   　　l.append(9)
   　　#  l=[1,3,4,5,7,3,8,9,9]
   　　l.append([8,9,9])
  　　 #  l=[1,3,4,5,7,3,8,9,[8,9,9]]

   L.extend(list) 向列表追加另一個列表 
     l=[1,3,4,5,7,3,8,9]
     l.extend([8,9,9])
     #  l=[1,3,4,5,7,3,8,9,8,9,9]
     等同於l += []

   L.clear() 清空列表,等同於 L[:] = [] 
     l=[1,3,4,5,7,3,8,9]
     l.clear()
     #l=[]

   L.sort(reverse=False) 將列表中的元素進行排序，預設順序按值的小到大的順序排列 
   　　l=[1,3,4,5,7,3,8,9]
   　　L.sort(reverse=False)
   　　l=[1,3,3,4,5,7,8,9]
     #False為升序，True為降序

   L.reverse() 列表的反轉，用來改變原列表的先後順序 
   　　l=[1,3,4,5,7,3,8,9]
   　　L.reverse()
   　　#l=[9,8,3,7,5,4,3,1]

   L.pop([index]) 刪除索引對應的元素，如果不加索引，預設刪除最後元素，同時返回刪除元素的引用關係 
     l=[1,3,4,5,7,3,8,9]
     m=l.pop(2)   #不等同於　　del
     #l=[1,3,5,7,3,8,9]
      m=4＇

練習三：
　寫一個程式，讓使用者輸入很多個正整數，當輸入小於０的數時結束輸入
　１）列印這些數中最大的數
　２）列印這些數中第二大的數
　３）刪除最小的一個數
　４）按原來順序打印出剩餘的這些數

 深拷貝和淺拷貝
 　
 淺拷貝：shallow copy
 　 淺拷貝是指在複製過程中，只複製一層變數，不會複製深層變數繫結的物件的複製過程
 　　示例程式碼：
 　　　　　l = [3.1, 3.2]　　　　　　　　　#繫結共用
   　　　l1 = [1, 2, l]
   　　　l2 = l1.copy()   　　　　　　#淺拷貝
   　　　print(l1)　　　　　　　　　　　　　　#[1, 2, [3.1, 3.2]]
   　　　print(l2)　　　　　　　　　　　　　　#[1, 2, [3.1, 3.2]]
   　　　l2[2][0] = 3.14
   　　　print(l1)   　　　　　　　　　　　#[1, 2, [3.14, 3.2]]
   　　　print(l2)   　　　　　　　　　　　#[1, 2, [3.14, 3.2]]

　深拷貝：deep copy
　　　複製物件及物件關聯的物件一起復制過程叫深拷貝
　　　示例程式碼：
　　　　　　import copy        　　　　　　　　　#匯入複製模組 
 　　　　　l = [3.1, 3.2]　　　　　　        
   　　　l1 = [1, 2, l]
   　　　l2 = copy.deepcopy(l1)   　　　#深拷貝
   　　　print(l1)　　　　　　　　　　　　　　　　　　　#[1, 2, [3.1, 3.2]]
   　　　print(l2)　　　　　　　　　　　        #[1, 2, [3.1, 3.2]]
   　　　l2[2][0] = 3.14
   　　　print(l1)   　　　　　           #[1, 2, [3.1, 3.2]]>>>>l1不變
   　　　print(l2)   　　　　　           #[1, 2, [3.14, 3.2]]＇

　列表和字串比較：
　　　　１．都是序列，有先後順序關係，有相同的運算操作
　　　　２．列表是可變的，字串是不可變的
　　　　３．列表可以存任意型別的資料，字串只能存字元
　　　　

　字串的文字解析方法：
　　　S.split(sep=None)將字串，使用sep作用分割符分割S字串，返回分割後的字串列表，當不給定引數時，使用空白字元作為分隔符分割
　　　S.join(interable)用可迭代物件中的字串，返回中間用S進行分割的字串
　　示例：
　　　　s = 'Beijing is capital'
    l = s.split(" ")
    # ["Beijing", "is", "capital"]
    
    s = 'Beijing#is#capital'
    l = s.split("#")
    # ["Beijing"#"is"#"capital"]

    常用空白字元
    \t \n \r \x

    l=['aaa','bbbb','ccccc']
    '$'.join(l)
    #生成 'aaa$bbbb$ccccc'

 練習四：
 　　有字串'hello'請生成'h e l l o'字串和'h-e-l-l-o'
   l = list('hello')
   l=' '.join(l)   #' '.join("hello")   #'h e l l o'
   l='_'.join(l)   #'h-e-l-l-o'

 列表推導式　　list comprehension
 　　列表推導式是用可迭代物件建立列表的表示式

 　作用：
 　　　用簡單方法生成列表
 　語法：
 　　　[表示式　for　變數　in　可迭代物件]
    #先執行可迭代物件，然後執行變數，最後執行表示式
 　　　或
 　　　[表示式　for 變數　in 可迭代物件　if 真值表達式]
 　　　#先執行可迭代物件，然後執行變數，之後執行if真值表達式，最後執行表示式
 　示例：
 　　　＃生成一個數值1~9的平方的列表
 　　　＃[１，４，９，１６，....８１]

 　　　＃不用推導式：
 　　　　l = []
     for i in range(1,10):
         l.append(i**2)
    ＃推導式實現：
    　l = [i**2 for i in range(1,10)]

 練習五：
　1. 用列表推導式生成1~100以內奇數的列表
　　　 結果是：[1,3,5,7,...99]

    l=[i for i in range(1,100,2)]
    等同於
    l=[i for i in range(1,100) if i %2 == 1]
 2.輸入一個開始的整數用begin繫結
 　　輸入一個結束的整數用end繫結
 　　將從begin開始，到end結束（不包含end）的所有偶數存於列表中，並列印此表
 　　（可以使用推到列表式完成，也可以用迴圈語句來完成）
 
 列表推導式的巢狀
 　語法：
 　　　[表示式　
      for 變數1　in 可迭代物件1　if 真值表達式1
            2          1           3
 　　　　　　　for 變數2　in 可迭代物件2　if 真值表達式2... ]
              5          4           6
   

  示例：
  　 #將列表[10, 20, 30] 中的元素與列表[1,2,3]　　　元素分別相加,將得到的元素放於一個列表中

    L = [x + y
          for x in [10, 20, 30]
            for y in [1,2,3]]
    print(L)  #[11, 12, 13, 21, 22, 23, 31,32,33]

 練習六：
 　用字串＂ABC＂和字串＂123＂生成如下列表
 　［'A1','A2','A3','B1','B2','B3','C1','C2','C3'］
  已知有一個字串：
  　s = '100,200,300,500,800'
   將其轉化為列表，列表的內部是整數
   L = [100,200,300,500,800] 

 課後練習：
 　1.有一些數存於列表中，如：
 　　　　　L = [1,3,2,1,6,4,2,....98,82]
   1)將列表L中出現的數字存於另一個列表L2中
   　　要求：
   　　　重複出現多次的數字只在L2列表中保留一份
   ２）將列表中出現兩次的數字存於L3列表中（在L3列表中保留一份）
　　2.計算出100以內的素數，將這些素數存於列表中，最後打印出列表中的這些素數
　　3.生成４０個斐波那契數（Fibonacci）
    1 1 2 3 5 8 13 21 ......
    要求將這數整數存於列表L中,最後打印出這些數
    (斐波那契的前兩個是1, 1, 之後的數是前兩個數的和)