容器型別的進階使用（串列、元組）

1. 串列同元組的拼接和重復
2. 串列同元組的索引和資料元素的獲取
3. 串列同元組的切片
4. 串列同元組元素的修改和洗掉
5. 串列同元組的內置函式

本文目錄

@

• 容器型別的進階使用（串列、元組）
  • • 本文目錄
    • 串列和元組的拼接和重復
    • 串列同元組的索引和資料元素的獲取
    • 串列同元組的切片
    • 串列同元組元素的修改和洗掉
      • • 修改資料元素
        • 洗掉資料元素
    • 串列同元組的內置函式
      • 串列增刪改查相關函式
        • 添加資料
        • 洗掉資料
      • 串列元組共同的常用內置函式
        • index
        • count
        • sort
        • reverse

串列和元組的拼接和重復

使用 + 可以將多個串列或者是元組結合成為一個

lst = [1, 2, 3]
lst1 = ['one', 'two', 'three']
res =lst + lst1
print(res)  # [1, 2, 3, 'one', 'two', 'three']


tup = (11, 22, 33)
tup1 = ('aa', 'bb', 'cc')
res = tup + tup1
print(res)  # (11, 22, 33, 'aa', 'bb', 'cc')

使用 * 可以將其中的元素重復多次

lst = [1, 2, 3] * 3
print(lst)  # [1, 2, 3, 1, 2, 3, 1, 2, 3]


tup = (11, 22, 33) * 2
print(tup)  # (11, 22, 33, 11, 22, 33)

串列同元組的索引和資料元素的獲取

我們之前說過，字串和串列、元組這三種容器的共同特點是，有序、可獲取，且都存在正逆向下標索引，

lst = ['one', 'two', 'three']
res = lst[0]
print(res)  # one


tup = ('aa', 'bb', 'cc')
res = tup[-1]
print(res)  # cc

串列同元組的切片

串列、元組和字串的切片的使用方法都是一模一樣的，這里我們就不再過多的敘說了，詳情請見上一篇，容器型別的進階使用（字串）：字串的切片，

語法：string[開始索引:結束索引:間隔值]

lst = ['宋江', '盧俊義', '吳用', '關勝', '林沖']

# 1、[開始索引:] 從開始截取至最后
res = lst[2:]
print(res)      # ['吳用', '關勝', '林沖']

# 2、[:結束索引] 從開頭截取至結束前一個元素
res = lst[:4]
print(res)      # ['宋江', '盧俊義', '吳用', '關勝']


# 3、[開始索引:結束索引] 從開始截取至結束前一個元素
res = lst[1:3]
print(res)      # ['盧俊義', '吳用']

# 4、[開始索引:結束索引:間隔值] 按照間隔值從開始截取至結束前一個元素
res = lst[1:4:2]
print(res)      # ['盧俊義', '關勝']

串列同元組元素的修改和洗掉

還記得我們的將六大資料型別的時候的總結嗎？串列是可修改的，而元組是不可修改的，既然不可修改也就不能洗掉其中的元素，

修改資料元素

如果我們要修改或者是洗掉串列或者是其它可修改的其它容器中的資料元素的時候，我要首先要指定資料元素的位置，就像獲取一樣，然后像定義變數一樣重新賦值一個新值，就可以將原有的舊資料覆寫掉，

# 指定一個元素位置賦予新值
lst[3] = '關羽'
print(lst)  # ['宋江', '盧俊義', '吳用', '關羽', '林沖']

也可以使用切片一次修改多個元素，沒有數量上的限制

# 選擇一個范圍，批量的賦予新值
lst[1:3] = '武松'
print(lst)  # ['宋江', '武', '松', '關勝', '林沖']

lst[1:3] = '武松', '魯智深'
print(lst)  # ['宋江', '武松', '魯智深', '關勝', '林沖']

# 注意，如果我們選擇的范圍過大，但是卻不能賦予同等數量的值，那么就會導致后面沒能賦予新值的值洗掉
lst[1:3] = '時遷',
print(lst)  # ['宋江', '時遷', '關勝', '林沖']

# 如果賦予的值過多，就會導致資料的插隊
lst[1:3] = '晁蓋', '阮小七', '李逵', '史進', '花榮'
print(lst)  # ['宋江', '晁蓋', '阮小七', '李逵', '史進', '花榮', '林沖']

元組是不可以修改資料的，那么元組中的串列的資料元素能修改嗎？答案是肯定的，元組不支持修改的元組的一級元素，

tup = (1, 2, 3, [4, 5, 6])
# tup[0] = '123'  # error，元組的資料元素不可以修改
tup[-1][1] = '劉備'
print(tup)  # (1, 2, 3, [4, '劉備', 6])

洗掉資料元素

說到洗掉資料元素，我們要學習一個關鍵字的使用 del，使用的樓就可以洗掉我們不想要的資料，以此來釋放記憶體，

語法：del + 資料

洗掉串列中的元素

# 單個洗掉
lst = ['宋江', '盧俊義', '吳用', '關勝', '林沖']
del lst[1]
print(lst)  # ['宋江', '吳用', '關勝', '林沖']

# 批量洗掉
lst = ['宋江', '盧俊義', '吳用', '關勝', '林沖']
del lst[1:4]
print(lst)  # ['宋江', '林沖']

del不僅可以洗掉容器中的資料，還可以直接洗掉變數

lst = ['宋江', '盧俊義', '吳用', '關勝', '林沖']

print(lst)  # ['宋江', '盧俊義', '吳用', '關勝', '林沖']

del lst
print(lst)  # error，名為lst的資料不存在

串列同元組的內置函式

串列增刪改查相關函式

在上面我們對串列這個難的資料元素進行操作的時候，感覺局限性很大，而且有很大的不適感，更關鍵的地方在于有對資料誤操作的可能性，所以我們更推薦使用內置函式來對資料元素進行相關的操作，

添加資料

append末尾添加資料，單個添加

lst = [1, 2, 3]
lst.append('msr')
print(lst)  # [1, 2, 3, 'msr']

insert在指定的位置之前添加資料

lst.insert(1, 'msr20666')
print(lst)  # [1, 'msr20666', 2, 3, 'msr']
lst.insert(-1, 'hello')
print(lst)  # [1, 'msr20666', 2, 3, 'hello', 'msr']

添加資料只有使用 +和extend才可以批量的添加資料，但是+只能和同等的資料型別，而extend可以支持可迭代的資料型別，

# 使用extend迭代添加資料元素
lst = [1, 2, 3]
newcont = [11, 22, 33]
lst.extend(newcont)
print(lst)  # [1, 2, 3, 11, 22, 33]

# 支持其它的可迭代的資料型別
newcont1 = 'abc'
lst.extend(newcont1)
print(lst)  # [1, 2, 3, 11, 22, 33, 'a', 'b', 'c']

洗掉資料

使用pop洗掉指定索引元素，默認值為-1

lst = [1, 2, 3, 4, 5]
res = lst.pop()
print(res)  # 5
print(lst)  # [1, 2, 3, 4]

res = lst.pop(3)
print(res)  # 4
print(lst)  # [1, 2, 3]

使用remove洗掉指定的值，如果有多個相同的值，洗掉第一個，如果沒有這個值，就會報錯，

lst = ['msr20666', 'msr', 1, 2, 3, 'msr']

lst.remove('msr')
print(lst)  # ['msr20666', 1, 2, 3, 'msr']

lst.remove(4)   # error, 沒有這個值

使用clear清空串列

lst = [1, 2, 3, 4]
lst.clear()
print(lst)  # []

串列元組共同的常用內置函式

index

獲取某個元素的索引值；如果有多個相同的值，獲取第一個資料的索引值；如果沒有該資料，就會報錯，

語法 ：container.index(value, [start], [end])

# 查找某個資料的索引
lst = [1, 2, 3, 1, 2, 3]
res = lst.index(1)
print(res)  # 0

# 在某個范圍中查找
tup = (1, 2, 3, 1, 2, 3)
res = lst.index(1, 3)	# 從索引3開始查找資料1
print(res)  # 3

count

計算某個元素出現的數量，串列中的count與字串中的不同，字串中的count可以劃定范圍，串列中的不支持此功能，

lst = [1, 2, 3, 1, 2, 3]
res = lst.count(1)
print(res)  # 2

sort

給容器中的資料元素按照大小進行排序，默認是從小到大的，

# 默認情況是從小到大排序的
lst = [1, 334, 44, 55, 56, 65, 67, 78,]
lst.sort()
print(lst)  # [1, 44, 55, 56, 65, 67, 78, 334]

sort也可以按照從大到小的順序進行排序，默認情況下sort的引數reverse的值是False，只要將值改成True即可，

lst = [1, 334, 44, 55, 56, 65, 67, 78,]
lst.sort(reverse=True)
print(lst)  # [334, 78, 67, 65, 56, 55, 44, 1]

字串進行排序，如果是數字型別的字串進行排序，不是按照數字的大小進行，而是按照第一位的元素進行排序，如果第一位相同，然后按照第二位，依次類推；如果是英文字母，按照ASCII編碼進行排序，排序的方法和規則和數字字串相同；如果是中文或者是其它的字符，排序沒有規律可言；一個串列中如果有字串型別和數字型別，不能使用排序，否則報錯，

# 排序數字
lst = ['1', '334', '44', '55', '56', '65', '67', '78',]
lst.sort()
print(lst)  # ['1', '334', '44', '55', '56', '65', '67', '78']

# 排序字母，按照ASCII碼表，正序為：A -> Z -> a -> z
lst = ['apple', 'Microsoft', 'IBM', 'huawei', 'Cisco']
lst.sort()
print(lst)  # ['Cisco', 'IBM', 'Microsoft', 'apple', 'huawei']

ASCII編碼表

[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-U7YR9g3f-1647077804821)(imgs/ASCII.jpg)]

reverse

將串列中的順序反轉

lst = [1, 2, 3, 4, 5, 6, 7, 8, 9]
lst.reverse()
print(lst)  # [9, 8, 7, 6, 5, 4, 3, 2, 1]

標籤：其他

上一篇：數字邏輯實踐6-> 從數字邏輯到計算機組成 | 邏輯元件總結與注意事項

下一篇：【JavaWeb-Servlet】筆記（2）--- Http狀態碼；多個Servlet之間呼叫規則；重定向解決方案；請求轉發解決方案