一、串列

1.串列介紹

串列，資料型別為list，可以存盤多個不同種類的元素，其中，字串元素需要加引號，且元素間要用逗號隔開，

在Python中，可以直接使用方括號創建，例如：

list_mix=['a',2,'c',4.5,'end']
#也可以是雙引號

2.串列讀取

在串列出生的時候，里面的每個元素就有都了對應的編號：

后文中將這個編號稱為“下標”

讀取單個元素

如果需要列印單一元素，例如c，就可以通過

list_mix=['a',2,'c',4.5,'end']
print(list_mix[2])

或者

list_mix=['a',2,'c',4.5,'end']
print(list_mix[-3])

的方式來實作，

讀取串列的一部分

切片
切片相當于把串列中的一部分元素切出來，格式為list_mix[n: m :k]，n為起始位置，m為結束位置，k為步長值，這種表達中，n默認為0，m默認為串列元素的個數，k默認為1，n、m、k想要保持默認時可以省略，

list_mix=['a',2,'c',4.5,'end']
print(list_mix[0:])
print(list_mix[:])
print(list_mix[::])
print(list_mix)
#這四中表達的輸出結果是相同的
#結果均為['a', 2, 'c', 4.5, 'end']
print(list_mix[0::2])
print(list_mix[0:5:2])
#輸出的結果相同
#結果均為['a', 'c', 'end']
print(list_mix[0:2])
print(list_mix[0:2:1])
#輸出結果相同
#結果均為['a', 2]

#中括號內不可以為空
#list_mix[m]所代表的元素無法取到

復制串列
①用切片的方法進行串列復制：

list_mix=['a',2,'c',4.5,'end']
b=list_mix[:]

這種方式可以將當前的list_mix串列復制給b，盡管和list_mix有著相同的元素和排列方式，b卻是一個單獨的串列，此后對list_mix串列進行操作，不會再影響b串列，
②用賦值的方法進行串列復制：

list_mix=['a',2,'c',4.5,'end']
b=list_mix

這種方法是將list_mix的地址傳遞給b，b并不是新的串列，好比b和list_mix是兩把一樣的鑰匙，計算機可以通過任何一把打開串列，此后再對串列進行操作時，無論通過b還是list_mix打開串列，結果也是一樣的，

3.串列的修改

①增添元素
在末尾增加一個元素：append()

list_mix=['a',2,'c',4.5,'end']
list_mix.append('app')
print(list_mix)
#結果為：['a', 2, 'c', 4.5, 'end', 'app']

在指定位置增加一個元素：insert( )
使用insert()函式需要指明想要添加的位置和想要添加的內容

list_mix=['a',2,'c',4.5,'end']
list_mix.insert(3,'add')
#insert()函式里的3表示list_mix串列里的第三個元素
#因此這里是在c后面添加add
print(list_mix)
#結果為['a', 2,  'c','add', 4.5, 'end']

②洗掉元素
洗掉末尾元素：pop()
pop()的回傳值是末尾元素值，因此可以保存被洗掉的元素

list_mix=['a',2,'c',4.5,'end']
deleted=list_mix.pop()
print(list_mix,deleted,deleted)
#輸出的結果為['a', 2, 'c', 4.5] end

此外，pop()還可以洗掉掉指定下標的元素：

list_mix=['a',2,'c',4.5,'end']
list_mix.pop(2)
#洗掉list_mix串列中下表為2的元素:c
print(list_mix,deleted)
#輸出的結果為['a', 2, 4.5, 'end']

洗掉指定下標的元素：del

list_mix=['a',2,'c',4.5,'end']
del list_mix[2]
#洗掉list_mix串列中下表為2的元素:c
print(list_mix)
#輸出結果為['a', 2, 4.5, 'end']

洗掉只知道內容，不知道下標的元素：remove()

list_mix=['a',2,'c',4.5,'end']
list_mix.insert(3,'c')
print(list_mix)
list_mix.remove('c')
print(list_mix)
#輸出結果為['a', 2, 'c', 'c', 4.5, 'end']
#          ['a', 2, 'c', 4.5, 'end']

從以上結果中可以看出，remove()只能洗掉第一個遇到的“c”，如果串列里有多個“c”，無法一次性通過remove()全部洗掉，

4.其他常用操作串列的函式

生成數字串列：list(),range(n,m,k)
這里n、m、k的含義與串列切片中的相同，表達方式也有一些近似，但需要注意的是range(,m,k)、range(n,k)、range(n,)這三種表達是錯誤的，

figure=list(range(10))
print(figure)
#結果為[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
#生成的數字串列中最大的元素一定小于m

figure=list(range(10,))
print(figure)
#結果為[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

figure=list(range(2,10,2))
print(figure)
#結果為[2, 4, 6, 8]

figure=list(range(2,10))
print(figure)
#結果為[2, 3, 4, 5, 6, 7, 8, 9]

串列排序
①臨時排序：sorted( )
sorted()函式只能暫時改變串列的順序，執行完后，原來的串列順序不變，

word=['zhang','chen','wang','chu']
print(sorted(word))
rank=sorted(word)
print(rank)
print(word)
#結果為：['chen', 'chu', 'wang', 'zhang'] 
#        ['chen', 'chu', 'wang', 'zhang'] 
#        ['zhang', 'chen', 'wang', 'chu']

②永久排序：sort()
sort()函式執行完后，原來串列的順序發生永久性改變

word=['zhang','chen','wang','chu']
word.sort()
print(word)
#結果為：['chen', 'chu', 'wang', 'zhang']

③倒序排序：reverse( )
reverse( )函式可以將原串列改為倒序，這一改動也是永久性的，

word=['zhang','chen','wang','chu']
word.reverse()
print(word)
#結果為：['chu', 'wang', 'chen', 'zhang']

④串列求長：len()

word=['zhang','chen','wang','chu']
print(len(word))
#結果為：4

二、字典

1.字典的介紹

和串列一樣，字典也是python中一種復雜的資料型別（dict），這種資料型別有以下特點：

1. 字典可以嵌套使用
2. 字典中的元素成對出現，體現為鍵 (key)和值 (value)
3. 鍵與值之間用冒號 :分隔，每個鍵值對之間用逗號 ,分隔
4. 一個字典中每個鍵只能出現一次，而值可以重復出現
5. 鍵只能使用英文的字符或字串表示
   字典可以用花括弧{}創建，例如：

fc1={'a':90,'b':80,'c':60,'a':60}
fc2={'a':90,'b':80,'c':60}
print(fc1)
print(fc2)
#結果為{'a': 60, 'b': 80, 'c': 60}
       {'a': 90, 'b': 80, 'c': 60}

由以上結果可以看出，如果字典的鍵出現重復，計算機會記錄第一次出現鍵的位置和第二次出現鍵的對應值，

2.字典的讀取

①字典的遍歷
一般有兩種方法可以列印字典的全部內容，即

fc={'a':90,'b':80,'c':60}
print(fc)

又或者

print(fc.items())
#這兩種方式輸出的結果均為：{'a': 90, 'b': 80, 'c': 60}

②遍歷鍵
想要遍歷字典鍵可以使用key()函式，代碼示例如下：

fc={'a':90,'b':80,'c':60,}
print(fc.keys())
#結果為：dict_keys(['a', 'b', 'c'])

③遍歷值
想要遍歷字典值可以使用value()函式，代碼示例如下：

fc={'a':90,'b':80,'c':60}
print(fc.values())
#結果為：dict_values([90, 80, 60])

④字典取值
字典取值有兩種方式，都需要依賴字典的鍵，
方法一
在字典變數后面加入“ [‘key’] ”以取得字典的值，示例如下

fc={'a':90,'b':80,'c':60,}
print(fc['a'])
#結果為：90

這種方法有一個缺點，如果輸入的鍵不存在，那么代碼運行時計算機會報錯；
方法二
使用get()函式取值
當輸入的鍵不存在時，回傳為None

fc={'a':90,'b':80,'c':60}
print(fc.get('a'))
print(fc.get('d'))
#結果為：90
#       None

需要注意的是，get()函式可以傳遞兩個引數，當寫入是兩個引數時，如果第一個引數為字典中的鍵，則無論第二個引數是什么，都只回傳第一個鍵對應的值，示例如下：

fc={'a':90,'b':80,'c':60}
print(fc.get('a','b'),fc.get('a','a'),fc.get('a','d'))
#結果為：90 90 90

相似情況下，如果第一個引數不是字典中的鍵，get()函式將回傳第二個值，但需要注意的是，這并不代表get()函式給字典加入了新的元素，示例如下：

fc={'a':90,'b':80,'c':60}
print(fc.get('d',100),fc)
#結果為：100 {'a': 90, 'b': 80, 'c': 60}

3.字典的元素增減

新增
字典元素的新增可以直接通過給出新增鍵并對其賦值完成，示例如下：

fc={'a':90,'b':80,'c':60}
fc['d']=100
print(fc)
#結果為：{'a': 90, 'b': 80, 'c': 60, 'd': 100}

需要注意的是，如果這里的鍵字典里已經存在，則執行更改對應值的操作，這是字典的普適邏輯，示例如下：

fc={'a':90,'b':80,'c':60}
fc['b']=100
print(fc)
#結果為：{'a': 90, 'b': 100, 'c': 60, 'd': 100}

可以通過這樣的方式來修改字典值，
此外，還可以通過update()函式批量增加字典元素，示例如下：

fc={'a':90,'b':80,'c':60}
fc.update(d=90,f='zero')
print(fc)
#結果為：{'a': 90, 'b': 80, 'c': 60, 'd': 90, 'f': 'zero'}

使用update()函式時，也可以進行批量修改，或者新增和修改同時進行：

fc={'a':90,'b':80,'c':60}
fc.update(a=95,b='85')
print(fc)
fc.update(d=90,f='zero')
print(fc)
fc.update(a=90,e='61')
print(fc)
#結果為：{'a': 95, 'b': '85', 'c': 60}
#       {'a': 95, 'b': '85', 'c': 60, 'd': 90, 'f': 'zero'}
#       {'a': 90, 'b': '85', 'c': 60, 'd': 90, 'f': 'zero', 'e': '61'}

洗掉

1. 使用 pop() 函式洗掉，向pop()傳遞要洗掉的鍵，就可以將制定的元素洗掉，pop()函式有回傳值，回傳為被洗掉的值，示例如下：

fc={'a':90,'b':80,'c':60}
print(fc.pop('a'),fc)
#結果為：90 {'b': 80, 'c': 60}

2. 可以用del進行洗掉，但需要注意使用del的格式，示例如下：

fc={'a':90,'b':80,'c':60}
del fc['a']
print(fc)
#結果為：{'b': 80, 'c': 60}

3. popitem()函式，該函式可以洗掉字典的最后一個元素，其回傳值型別為 tuple，值為被洗掉的元素，示例如下：

fc={'a':90,'b':80,'c':60}
kv=fc.popitem()
print(kv,type(kv),fc)
#結果為：('c', 60) <class 'tuple'> {'a': 90, 'b': 80}

4. clear()函式：清空字典，示例如下：

fc={'a':90,'b':80,'c':60}
fc.clear()
print(fc)
#結果為：{}