python_列表和元組

1.1.列表定義

列表是python中內(nèi)置有序可變序列，列表的所有元素放在一對中括號“[]”中，并使用逗號分隔開；
一個列表中的數(shù)據(jù)類型可以各不相同，可以同時分別為整數(shù)、實數(shù)、字符串等基本類型，甚至是列表、字典以及其他自定義類型的對象。
例如：

[1, 2, 3, 2.4, 5]
[0.01, "zhangsan", [1,2,3]]

創(chuàng)建

  • 使用“=”直接將一個列表賦值給變量即可創(chuàng)建列表對象。例如：a_list = [], b_list = [1, 2, 3]
  • 使用list()函數(shù)將元組、range對象、字符串或其他類型的可迭代對象類型的數(shù)據(jù)轉(zhuǎn)換為列表。
    例如：a_list = list("Hello")將字符串"hello"轉(zhuǎn)換成列表['H', 'e', 'l', 'l', 'o']
    刪除 當(dāng)不再使用時，使用del命令刪除整個列表 例如：
>>>x = [1, 2, 3]
>>>del x[1]            #刪除指定位置元素
>>>x
[1, 3]
>>>del x               #刪除整個列表
>>>x
Traceback (most recent call last):
   File "<pyshell#6>", line 1, in <module>
             x
NameError: name 'x' is not defined

1.2.列表元素的增加

1.2.1.append()

向列表尾部追加一個元素，不改變其內(nèi)存首地址，屬于原地操作。例如：

x = [1, 2, 3]
x.append(4)
print(x)

輸出：

[1, 2, 3, 4]

1.2.2.insert()

向列表任意位置插入一個元素，不改變其內(nèi)存首地址，屬于原地操作。
例如：

x = [1,3,4]
x.insert(1,2)
print(x)

輸出：

[1, 2, 3, 4]

1.2.3.extend()

將另一個迭代對象的所有元素添加至該列表對象尾部，不改變其內(nèi)存地址，屬于原地操作。
例如：

x = [1,2]
x.extend([3,4])
print(x)

輸出：

[1, 2, 3, 4]

1.3.運(yùn)算符"+"和"*"

并不是真的為列表添加元素，而是創(chuàng)建一個新列表，不屬于原地操作，而是返回新列表。

x = [1,2,3]
y = x + [4]
print(y)
y = x*2
print(y)

輸出：

[1, 2, 3, 4]
[1, 2, 3, 1, 2, 3]

此時x保持不變，依舊是[1,2,3]

1.4.列表元素的刪除

1.4.1.pop()

使用列表的pop()方法刪除并返回指定（默認(rèn)為最后一個）位置上的元素，如果給定的索引超出了列表的范圍，則拋出異常。

x = [1,2,3,4]
print(x.pop())
print(x.pop(1))

輸出：

4
2

1.4.2.remove()

刪除首次出現(xiàn)的指定元素，如果列表中不錯在要刪除的元素，則拋出異常。
例如：

x = [1,2,3,4]
x.remove(2)
print(x)

輸出：

[1, 3, 4]

1.4.3.del

刪除列表中的指定位置上的元素。
例如：

x = [1,2,3,4]
del x[1]
print(x)

輸出：

[1, 3, 4]

1.5.列表元素訪問與計數(shù)

1.5.1.count()

統(tǒng)計指定元素在列表對象中出現(xiàn)的次數(shù)。
例如：

x = [1,2,3,3,4,5]
print(x.count(3))
print(x.count(0))

輸出：

2
0

1.5.2.index()

獲取指定元素首次出現(xiàn)的下標(biāo)，若列表對象中不存在指定元素，則拋出異常。
例如：

x = [1,2,3,2,2,4]
print(x.index(2))

輸出：

1

1.5.3.in

測試列表中是否存在某元素
例如：

x = [1,2,3,4]
print(3 in x)
print(5 in x)

輸出：

True
False

1.6.列表排序

1.6.1.sort()

按照指定規(guī)則對所有元素進(jìn)行排序，默認(rèn)規(guī)則是直接比較規(guī)則大小。
例如：

aList = [3,4,5,6,7,9,11,13,15,17]
import random
random.shuffle(aList)                         #隨機(jī)降序
print(aList)
aList.sort()                                  #默認(rèn)是升序排序
aList.sort(reverse = True)                    #降序排序
print(aList)

輸出：

[15, 4, 13, 11, 5, 17, 9, 3, 7, 6]
[17, 15, 13, 11, 9, 7, 6, 5, 4, 3]

1.6.2.reverse()

將列表中所有元素原地逆序排列。
例如：

x = [6,4,2,4,1]
print(sorted(x))
print(sorted(x,reverse = True))
print(x)

輸出：

[1, 2, 4, 4, 6]
[6, 4, 4, 2, 1]
[6, 4, 2, 4, 1]

1.6.4.reversed()

返回一個逆序排列后的迭代對象，不對原列表做任何修改。
例如：

x = [1,5,3,6,2]
print(list(reversed(x)))
print(x)

輸出：

[2, 6, 3, 5, 1]
[1, 5, 3, 6, 2]

1.7.用語序列操作的常用內(nèi)置函數(shù)

1.7.1.len()

返回列表中的元素個數(shù)，同樣適用于元組、字典、集合、字符串等。

1.7.2.max()、min()

返回列表中的最大或最小元素，同樣適用于元組、集合、range對象等。

1.7.3.sum()

對列表的元素進(jìn)行求和運(yùn)算。

1.7.4.zip()

返回可迭代的zip對象。
例如：

aList = [1, 2, 3]
bList = [4, 5, 6]
cList = zip(aList, bList)
print(cList)
print(list(cList))

輸出：

<zip object at 0x0000020CBC537D08>
[(1, 4), (2, 5), (3, 6)]

1.7.5.enumerate()

枚舉列表元素，返回枚舉對象，其中每個元素為包含下標(biāo)和值的元組。該函數(shù)對元組、字符串同樣有效。
例如：

for item in enumerate('abcdef'):
    print(item)

輸出：

(0, 'a')
(1, 'b')
(2, 'c')
(3, 'd')
(4, 'e')
(5, 'f')

1.8.遍歷列表的三種方式

a = ['a','b','c','d','e','f']
for i in a:
    print(i)
for i in range(len(a)):
    print(i,a[i])
for i,ele in enumerate(a):
    print(i,ele)

輸出：

a
b
c
d
e
f
0 a
1 b
2 c
3 d
4 e
5 f
0 a
1 b
2 c
3 d
4 e
5 f

1.9.列表推導(dǎo)式

列表推導(dǎo)式使用非常簡潔的方式來快速生成滿足特定需求的列表，代碼具有非常強(qiáng)的可讀性。
語法形式：[表達(dá)式 for 變量 in 序列或迭代對象]
列表推導(dǎo)式在邏輯上相當(dāng)于一個循環(huán)，知識形式更加簡潔。

lis = [i for i in range(100)]
print(lis)

使用列表推導(dǎo)式實現(xiàn)嵌套列表的平鋪

ves = [[1,2,3],[4,5,6],[7,8,9]]
print([num for elem in ves for num in elem])

輸出：

[1, 2, 3, 4, 5, 6, 7, 8, 9]

過濾不符合條件的元素，從列表中選擇符合條件的元素組成新的列表

aList = [-1,-4,6,7.5,-2.3,9,-11]
print([i for i in aList if i>0])

[6, 7.5, 9]

在列表推導(dǎo)式中使用多個循環(huán)，實現(xiàn)多序列元素的任意組合，并且可以結(jié)合條件語句過濾特定元素

print([(x,y) for x in range(3) for y in range(3)])

[(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]

print([(x,y) for x in [1,2,3] for y in [3,1,4] if x != y])

[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

列表練習(xí)
寫一個循環(huán)，不斷地問用戶想買什么，用戶選擇一個商品編號，就把相應(yīng)的商品添加到購物車?yán)铮罱K用戶輸入q退出時，打印購物車?yán)锏纳唐妨斜?/p> 

products = [['iphone',6888],['三星',30000],['小米',2500]]
shopping_car = []
flag = True
while flag:
    print("******商品列表******")
    for index,i in enumerate(products):
        print("%s, %s| %s" %(index,i[0],i[1]))
    choice = input("請輸出您想購買的商品的編號：")
    if choice.isdigit():#isdigit()判斷變量是什么類型
        choice = int(choice)
        if choice >= 0 and choice < len(products):
            shopping_car.append(products[choice])
            print("已經(jīng)將%s加入購物車" % (products[choice]))
        else:
            print("該商品不存在")
    elif choice == "q":
        if len(shopping_car)>0:
            print("您打算購買以下商品：")
            for index,i in enumerate(shopping_car):
                print("%s. %s| %s" %(index,i[0],i[1]))
        else:
            print("您的購物車中沒有添加商品")
        flag = False

輸出：

******商品列表******
0, iphone| 6888
1, 三星| 30000
2, 小米| 2500
請輸出您想購買的商品的編號：0
已經(jīng)將['iphone', 6888]加入購物車
******商品列表******
0, iphone| 6888
1, 三星| 30000
2, 小米| 2500
請輸出您想購買的商品的編號：1
已經(jīng)將['三星', 30000]加入購物車
******商品列表******
0, iphone| 6888
1, 三星| 30000
2, 小米| 2500
請輸出您想購買的商品的編號：2
已經(jīng)將['小米', 2500]加入購物車
******商品列表******
0, iphone| 6888
1, 三星| 30000
2, 小米| 2500
請輸出您想購買的商品的編號：q
您打算購買以下商品：
0. iphone| 6888
1. 三星| 30000
2. 小米| 2500

1.10.列表切片

使用索引獲取列表的元素（隨機(jī)讀?。?br> 列表元素支持用索引訪問，正向所以從0開始

colors = ["red","blue","green"]
print(colors[0])
print(colors[1])
print(colors[2])
print(colors[-1])

red
blue
green
green

1.10.1.列表的切片操作

切片操作不是列表特有的，python中的有序序列都支持切片，如字符串，元組。
切片的返回結(jié)果類型和切片對象類型一致，返回的是切片對象的子序列，如：對一個列表切片返回一個列表，字符串切片返回字符串。
格式：li[start:end:step]
start是切片起點索引，end是切片終點索引，但切片結(jié)果不包括終點索引的值。step是步長默認(rèn)是1。

li=["A","B","C","D"]
t=li[0:3]  #起點的0索引可以省略
print(t)
t=li[2:]   #省略end，則切到末尾
print(t)
t=li[1:3]
print(t)
t=li[0:4:2] #從li[0]到li[3]，設(shè)定步長為2.
print(t)

如何確定start和end，是什么關(guān)系？在step的符號一定的情況下，start和end可以混合使用正向和反向索引，無論怎樣，你都要保證start和end之間有和step反向一致元素間隔，否則會切出空列表。

t=li[0:2]
t=li[0,-2]
t=li[-4,-2]
t=li[-4,2]

上面的結(jié)果都是一樣的：t為["A","B"]


t=li[-1:-3:-1]
t=li[-1:1:-1]
t=li[3:1:-1]
t=li[3:-3:-1]

上面的結(jié)果都是一樣的：t為["D","C"]

t=li[-1:-3]
t=li[-1:1]
t=li[3:1]
t=li[3:-3]

都切出空列表



同時，step的正負(fù)決定了切片結(jié)果的元素采集的先后
省略start和end表示以原列表全部為目標(biāo)

t=li[::-1]   t--->["C","B","A"]        #反向切，切出全部
t=li[:]       t--->["A","B","C","D"]  #正向切全部

1.10.2.使用切片來原地修改列表內(nèi)容

aList = [3,5,7]
aList[len(aList):] = [9]  #在尾部追加元素
print(aList)
aList[:3] = [1,2,3]       #替換前3個元素
print(aList)
aList[:3] = []            #刪除前3個元素
print(aList)

[3, 5, 7, 9]
[1, 2, 3, 9]
[9]

1.10.3.使用del與切片結(jié)合來刪除列表元素

aList = [3,5,7,9,11]
del aList[:3]     #刪除前3個元素
print(aList)
bList = [3,5,7,9,11]
del bList[::2]    #刪除偶數(shù)位置上的元素
print(bList)

[9, 11]
[5, 9]

1.10.4.切片返回的是列表元素的淺復(fù)制

所謂淺復(fù)制，是指生成一個新的列表，并且把原列表中所有元素的引用都復(fù)制到新列表中。
例如：

aList = [3,5,7]
bList = aList     #bList與aList指向同一個內(nèi)容
print(bList)
bList[1] = 8      #修改其中一個對象會影響另一個
print(aList)
print(aList == bList)    #判斷兩個列表的元素是否完全一致
print(aList is bList)    #判斷兩個列表是同一個對象
print(id(aList))         #內(nèi)存地址
aList = [3,5,7]
bList = aList[::]        #切片，淺復(fù)制
print(aList == bList)    #兩個列表的元素完全一致
print(aList is bList)    #兩個列表不是同一個對象
print(id(aList) == id(bList)) #內(nèi)存地址不一致
bList[1] = 8
print(bList)
print(aList)

[3, 5, 7]
[3, 8, 7]
True
True
2340905449608
True
False
False
[3, 8, 7]
[3, 5, 7]

1.11.元組

元組屬于不可變序列，一旦常見，用任何方法都不可以修改其元素。從形式上，元組的所有元素放在一對圓括號中，元素之間用逗號分隔。

1.11.1.元組的創(chuàng)建與刪除

創(chuàng)建 使用“=”將一個元組賦值給變量
例如：

x = (1,2,3)   #直接把元組賦值給一個變量
print(x)

創(chuàng)建只有一個元素的元組

x = (3)
print(type(x))
x = (3,)
print(type(x))

<class 'int'>
<class 'tuple'>

創(chuàng)建空元組的方法

x = ()
print(x)
x = tuple()
print(x)

()
()

使用tuple函數(shù)將其他序列轉(zhuǎn)換為元組

print(tuple(range(5)))
print(tuple('abcdefg'))    #把字符串轉(zhuǎn)換為元組
aList = [-1,-4,6,7.5,-2.3,9,-11]
print(tuple(aList))        #把列表轉(zhuǎn)換為元組

(0, 1, 2, 3, 4)
('a', 'b', 'c', 'd', 'e', 'f', 'g')
(-1, -4, 6, 7.5, -2.3, 9, -11)

刪除 使用del可以刪除元組對象，不能刪除元組中的元素

1.11.2.元組與列表的區(qū)別

  • 元組中的數(shù)據(jù)一旦定義就不允許更改。
  • 元組沒有append()、expend()和insert()等方法，無法向元組中添加元素
  • 元組沒有remove()或pop()方法，也無法對元組元素進(jìn)行del操作，不能從元組中刪除元素。
  • 從效果上看，tuple()凍結(jié)列表，而list()融化元組。

1.12.元組的優(yōu)點

  • 元組的速度比列表更快
  • 元組對不需要改變的數(shù)據(jù)進(jìn)行“寫保護(hù)”將使得代碼更加安全。
  • 元組可用作字典鍵（特別是包含字符串、數(shù)值和其他元組這樣的不可變數(shù)據(jù)的元組）。元組有時還作為函數(shù)的返回值返回（返回多個值）。
最后編輯于 ：
?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請聯(lián)系作者
【社區(qū)內(nèi)容提示】社區(qū)部分內(nèi)容疑似由AI輔助生成，瀏覽時請結(jié)合常識與多方信息審慎甄別。
平臺聲明：文章內(nèi)容（如有圖片或視頻亦包括在內(nèi)）由作者上傳并發(fā)布，文章內(nèi)容僅代表作者本人觀點，簡書系信息發(fā)布平臺，僅提供信息存儲服務(wù)。

相關(guān)閱讀更多精彩內(nèi)容

友情鏈接更多精彩內(nèi)容