第二章 列表和元組

在Python中，最基本的數據結構為序列（包括列表、元組、字符串等）（sequence）
列表是可以修改的，而元組不可以
Python支持一種數據結構的基本概念，名為容器（container）
容器基本上就是可包含其他對象的對象
兩種主要的容器是序列（如列表和元組）和映射（如字典）
在序列中，每個元素都有編號，而在映射中，每個元素都有名稱（也叫鍵）。
有一種既不是序列也不是映射的容器，它就是集合（set）

通用的序列操作

通用的序列操作包括索引、切片、相加、相乘和成員資格檢查

1，索引

索引中，下標從0開始訪問單個元素，0時第一個元素的位置
用負數索引時，Python將從右（即從最后一個元素）開始往左數，-1是最后一個元素的位置

beyond = "I love the band" beyond[0]#結果為：I beyond[2]#結果為：l beyond[-1]#結果為：d beyond[-2]#結果為：n "beyond"[2]#結果為：yfourth = input('Year: ')[3] 輸入結果：Year: 1999 輸出結果：'9'

2，切片:

除使用索引來訪問單個元素外，還可使用切片（slicing）來訪問特定范圍內的元素
簡而言之，左閉右開
切片索引方向只能從左向右，不能反過來操作，即左小右大，左閉右開
若要反過來操作需要指定步長即可

number = [0,1,2,3,4,5,6,7,8,9] number[1:3]#結果為：[1，2] number[4:5]#結果為：[4] number[8:10]#結果為：[8,9] 索引10，該元素壓根不存在，但是沒有報錯，壓根用不到，左閉右開number[-3:-1]#結果為：[7,8] number[-1:-3]#結果為：[] ''' 如果第一個索引指定的元素位于第二個索引指定的元素后面 （在這里，倒數第3個元素位于第1個元素后面），結果就為空序列 '''#切片結束于序列末尾，可省略第二個索引 number[-3:]#結果為：[7,8,9] #如果切片始于序列開頭，可省略第一個索引 number[:3]#結果為：[0,1,2] #要復制整個序列，可將兩個索引都省略 number[:]#結果為：[0,1,2,3,4,5,6,7,8,9]

設置步長的切片
通常情況不寫步長的時候，步長默認為1

number=[0,1,2,3,4,5,6,7,8,9] number[0:5]#結果為：[0,1,2,3,4] number[0:5:1]#結果為：[0,1,2,3,4] #不寫第三個參數步長的話默認為1number[0:10:2]#結果為：[0,2,4,6,8] 步長為2時，將從起點和終點之間每隔一個元素提取一個元素#要從序列中每隔3個元素提取1個，只需提供步長4即可 number[::4]#結果為：[0,4,8]#當然，步長不能為0，否則無法向前移動，但可以為負數，即從右向左提取元素 number[8:3:-1]#結果為：[8,7,6,5,4] number[3:8:-1]#結果為：[]#步長為正數時，它從起點移到終點 #步長為負數時，它從終點移到起點 number[5::-2]#結果為：[5,3,1] number[:5:-2]#結果為：[9,7]

3，序列相加+

[1,2,3] + [3,2,1]#結果為：[1,2,3,3,2,1] 'hello,' + "beyond"#結果為：'hello,beyond'[1,2,2] + "yanyu"#結果為：報錯！！！ #一般而言，不能拼接不同類型的序列

4，乘法*

“beyond” * 5#結果為：'beyondbeyondbeyondbeyondbeyond' [521] * 3#結果為：[521,521,521]''' Python中None表示什么都沒有，為空 將列表長度初始化為5如下： ''' beyond = [None] * 5 beyond#結果為：[None,None,None,None,None]

5，成員資格in

要檢查特定的值（可以是單個字符也可以是字符串）是否包含在序列中，可使用運算符in
它檢查是否滿足指定的條件，并返回相應的值，滿足時返回True，不滿足時返回False
這樣的運算符稱為布爾運算符，而前述真值稱為布爾值

beyond = "yanyu like beyond" 'y' in beyond#結果為：True 'q' in beyond#結果為：Falseusers = ['yanyu','huangjiaju','yeshirong'] input('Enter your user name:') in users Enter your user name:yanyu #結果為：True

長度、最小值、最大值
函數len返回序列包含的元素個數，min和max分別返回序列中最小和最大的元素

beyond = [19,5,22] len(beyond)#結果為：3 max(beyond)#結果為：22 min(beyond)#結果為：5max(1999,2005)#結果為：2005 min(98,55)#結果為：55

列表

函數list，使用字符串來創建列表
可將任何序列（而不僅僅是字符串）作為list的參數

list("beyond")#結果為：['b', 'e', 'y', 'o', 'n', 'd']

基本的列表操作包括索引、切片、拼接和相乘，但列表的有趣之處在于它
是可以修改的

1，修改列表：給元素賦值

beyond = [1,2,3,4,5] beyond[1] = 99 beyond#結果為：[1,99,3,4,5] #不能給不存在的元素賦值，因此如果列表的長度為2，就不能給索引為100的元素賦值

2，刪除元素del

yanyu = ["yanyu",1999,'huangjiaju'] del yanyu[1] yanyu#結果為：['yanyu','huangjiaju']

3，給切片賦值

yanyu = list("beyond") yanyu#結果為：['b', 'e', 'y', 'o', 'n', 'd']yanyu[2:] = list('SQ') yanyu#結果為：['b','e','S','Q'] yanyu[3:] = list("jiaju") yanyu#結果為：['b', 'e', 'S', 'j', 'i', 'a', 'j', 'u']＃在不替換原有元素的情況下插入新元素 yanyu[1:1] = [6,7,8] yanyu#結果為：['b', 6, 7, 8, 'e', 'S', 'j', 'i', 'a', 'j', 'u'] yanyu[1:3] = [] yanyu#結果為：['b', 8, 'e', 'S', 'j', 'i', 'a', 'j', 'u'] ''' 這很顯然與del yanyu[1:3]等效 類推，也可以對執行步長不為1的切片進行賦值 '''

4，列表方法

方法是與對象（列表、數、字符串等）聯系緊密的函數
object.method(arguments)
方法調用與函數調用很像，只是在方法名前加上了對象和句點
列表包含多個可用來查看或修改其內容的方法

1，append，將一個對象附加到列表末尾

yanyu = [1,2,4,5,6] yanyu.append(7) yanyu#結果為：[1,2,4,5,6,7]

2，clear，就地清空列表的內容

yanyu = [1,2,3] yanyu.clear() yanyu#結果為：[] #這類似于切片賦值語句yanyu[:] = []

3，copy，復制列表（將另一個名稱關聯到列表）

a = [1,2,3] b = a b[1] = 4 a#結果為：[1,4,3] #將另一個名稱關聯到列表a = [1,2,3] b = a.copy() b[1] = 4 a#結果為：[1, 2, 3] #這類似于使用a[:]或list(a)，它們也都復制a

4，count，計算指定的元素在列表中出現了多少次

['to', 'be', 'or', 'not', 'to', 'be'].count('to') #結果為：2 x = [[1, 2], 1, 1, [2, 1, [1, 2]]] x.count(1) #結果為：2 x.count([1, 2]) #結果為：1

5，extend，同時將多個值附加到列表末尾，可使用一個列表來擴展另一個列表

a = [1, 2, 3] b = [4, 5, 6] a.extend(b) a #結果為：[1, 2, 3, 4, 5, 6] #很明顯a這個列表已經發生了修改 ''' extend是將b擴展到a，a會發生變化會被擴展 而常規拼接+，只是返回一個新的序列，原本的不會被修改 ''' a = [1, 2, 3] b = [4, 5, 6] a + b #結果為：[1, 2, 3, 4, 5, 6] a #結果為：[1, 2, 3] #很明顯a這個列表并沒有改變 a = a+b#結果為：[1, 2, 3, 4, 5, 6] 效果實現了 但是拼接的效率將比extend低a = [1, 2, 3] b = [4, 5, 6] a[len(a):] = b a #結果為：[1, 2, 3, 4, 5, 6] #這雖然可行，但可讀性不是很高

6，index，查找指定值第一次出現的索引

yanyu= ['We', 'are', 'the', 'knights', 'who', 'say', 'huangjiaju'] yanyu.index('who') #結果為：4 who處于索引第4處 yanyu.index('xixihaha')#結果為：報錯 其不存在

7，insert，用于將一個對象插入列表

numbers = [1, 2, 3, 5, 6, 7] numbers.insert(3, 'four') numbers #結果為：[1, 2, 3, 'four', 5, 6, 7]''' 與extend一樣，也可使用切片賦值來獲得與insert一樣的效果 這雖巧妙，但可讀性根本無法與使用insert媲美 ''' numbers = [1, 2, 3, 5, 6, 7] numbers[3:3] = ['four'] numbers #結果為：[1, 2, 3, 'four', 5, 6, 7]

8，pop，從列表中刪除一個元素（末尾為最后一個元素），并返回這一元素

pop是唯一既修改列表又返回一個非None值的列表方法

x = [1,2,3，9，8，7] x.pop()#結果為：7 x#結果為：[1,2,3,9,8] x.pop(2)#結果為：3 x#結果為：[1,2,9,8] ''' 使用pop可實現一種常見的數據結構——棧（stack）后進先出 push和pop是大家普遍接受的兩種棧操作（加入和取走）的名稱 Python沒有提供push，但可使用append來替代 方法pop和append的效果相反，因此將剛彈出的值壓入（或附加）后，得到的棧將與原來相同要創建先進先出（FIFO）的隊列，可使用insert(0, ...)代替append 另外，也可繼續使用append，但用pop(0)替代pop()。 ''' x = [1,4,7] x.append(x.pop()) x#結果為：[1,4,7]

9，remove，用于刪除第一個為指定值的元素

remove是就地修改且不返回值的方法
不同于pop的是，它修改列表，但不返回任何值

x = ['I','love',"beyond",'and',"I",'hahaha'] x.remove("I") x#結果為： x.remove("SQ")#結果為：報錯 原因為列表里面沒有該元素

10，reverse，按相反的順序排列列表中的元素

修改列表，但不返回任何值（與remove和sort等方法一樣）

x = [1, 2, 3] x.reverse() x #結果為：[3, 2, 1]''' 如果要按相反的順序迭代序列，可使用函數reversed 這個函數不返回列表，而是返回一個迭代器，不改變原來的列表 ''' x = [1, 2, 3] list(reversed(x)) #結果為：[3, 2, 1] x#結果為：[1,2,3]

11，sort，用于對列表就地排序

sort方法：對原來的列表進行修改，使其元素按順序排列，且不返回任何值！！！
sorted函數：可用于任何序列，但總是返回一個列表

x = [7,4,1,8,9,6,5,2,3] x.sort() x#結果為：[1,2,3,4,5,6,7,8,9]y = [9,5,1,7,8,6] z = y.sort() print(z)#結果為：None 其原因在于，sort不返回任何值！！！ y#結果為：[1,5,6,7,8,9] y列表排序了，但是sort不返回任何值導致z為None#先將z關聯到y的副本，再對z進行排序 y = [9,5,1,7,8,6] z = y.copy() z.sort() z#結果為：[1, 5, 6, 7, 8, 9] z進行排序 y#結果為：[9, 5, 1, 7, 8, 6] y并未修改#另一種方式是使用函數sorted x = [4, 6, 2, 1, 7, 9] y = sorted(x) y #結果為：[1, 2, 4, 6, 7, 9] x #結果為：[4, 6, 2, 1, 7, 9] #如果要將元素按相反的順序排列，可先使用sort（或sorted），再調用方法reverse，也可使用參數reversesorted('Python') #結果為：['P', 'h', 'n', 'o', 't', 'y'] 大寫字母<小寫字母，相同類型字母a或A最小

12，高級排序

方法sort接受兩個可選參數（關鍵字參數）：key和reverse
參數key類似于參數cmp：你將其設置為一個用于排序的函數
參數reverse：只需將其指定為一個真值（True或False），以指出是否要按相反的順序對列表進行排序
要根據長度對元素進行排序，可將參數key設置為函數len

x = ["qwert","asf",'zx',"vxcb",'sdfsd'] x.sort(key=len) x#結果為：['zx', 'asf', 'vxcb', 'qwert', 'sdfsd']y = [4,6,8,2,1,9,7] y.sort(reverse=True) y#結果為：[9, 8, 7, 6, 4, 2, 1]

元組：不可修改的序列()

元組語法很簡單，只要將一些值用逗號分隔，就能自動創建一個元組

1,2,3#結果為：(1, 2, 3) 元組 (1,2,3)#結果為：(1, 2, 3) 元組#逗號很關鍵，若只有一個數時，不加逗號就代表數，加上逗號代表元組 1999#結果為：1999 數 1999,#結果為：(1999,) 元組 (1999,)#結果為：(1999,) 元組

函數tuple的工作原理與list很像：它將一個序列作為參數，并將其轉換為元組
如果參數已經是元組，就原封不動地返回它

tuple([1, 2, 3])#結果為：(1, 2, 3) tuple('abc')#結果為：('a', 'b', 'c') tuple((1, 2, 3))#結果為：(1, 2, 3)

元組的創建及其元素的訪問方式與其他序列相同

x = 1, 2, 3 x#結果為：(1,2,3) x[1]#結果為：2 x[0:2] #結果為：(1, 2)

本章節介紹的新函數

函 數描 述

len(seq)	返回序列的長度
list(seq)	將序列轉換為列表
max(args)	返回序列或一組參數中的最大值
min(args)	返回序列和一組參數中的最小值
reversed(seq)	讓你能夠反向迭代序列
sorted(seq)	返回一個有序列表，其中包含指定序列中的所有元素
tuple(seq)	將序列轉換為元組

總結

以上是生活随笔為你收集整理的第二章 列表和元组的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。