Python 3.5筆記

第三章 列表與元組

通用序列操作

索引

序列是Python中最基本的數(shù)據(jù)結(jié)構(gòu)。序列中的每個元素都分配一個數(shù)字办龄，代表它在序列中的位置（索引）烘绽，從0開始。獲取元素的方式為：在變量后加中括號俐填，在中括號中輸入所取元素的編號值安接。索引的位置可以從左到右，也可以從右到左玷禽。從左到右時從0開始赫段，從右到左時從-1開始。

greeting = "Hello"
print(greeting[0])
print(greeting[-1])

輸出：

H
o

對于字符串矢赁，不定義變量糯笙，直接使用索引也是可以的

print("hello"[1])

輸出

e

分片

索引用來對單個元素進行訪問，使用分片可以對一定范圍內(nèi)的元素進行訪問撩银。分片通過冒號相隔的兩個索引實現(xiàn)给涕。

分片操作即支持正數(shù)索引，也支持負數(shù)索引额获。分片中最左面的元素必須比最右面的元素早出現(xiàn)在序列中够庙。（并不是指左面的索引比右面的元素數(shù)值小）抄邀，否則就返回一個空序列耘眨。

分片操作的實現(xiàn)需要提供兩個索引作為邊界。第一個索引的元素包含在分片內(nèi)境肾，第二個索引的元素不包含在分片內(nèi)剔难。像數(shù)學中的a<=x<b胆屿，x是我們需要得到的元素，a是分片操作的第一個索引偶宫，b是第二個索引非迹，b不包含在x的范圍內(nèi)。

number = [1,2,3,4,5,6,7,8,9,10]
print(number[0:3])
print(number[-1:-3])#分片中最左面的元素必須比最右面的元素早出現(xiàn)在序列中
# （并不是指左面的索引比右面的元素數(shù)值写壳鳌）憎兽，否則就返回一個空序列
print(number[-3:-1])
print(number[-3:0])#比如這個時候就會返回空置，所以注意理解上面那句話吵冒，
#即：最左面的元素必須比最右面的元素早出現(xiàn)在序列中
# （并不是指左面的索引比右面的元素數(shù)值写棵）

輸出：

[1, 2, 3]
[]
[8, 9]
[]

如果需要取得的分片包括序列結(jié)尾的元素，只需將第二個索引設(shè)置為空即可桦锄。

#如果需要取得的分片包括序列結(jié)尾的元素扎附，只需將第二個索引設(shè)置為空即可
print(number[-3:])
print(number[0:])
print(number[:0])#最后一個元素為第一個蔫耽，輸出為空
print(number[:3])
print(number[:])#輸出整個數(shù)組

輸出

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

步長

分片中使用步長用于取序列中不連續(xù)的元素结耀。沒有設(shè)置步長時，也可以理解為默認步長是1匙铡。

print(number[0:10:1])
print(number[0:10:2])
print(number[2:5:3])
print(number[::3])

輸出

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

輸入的步長不能為0

print(number[0:10:0]) #輸入的步長不能為0

輸出

Traceback (most recent call last):
  File Chapter3.py, line 29, in <module>
    print(number[0:10:0])
ValueError: slice step cannot be zero

輸入的步長也可以是負數(shù)图甜，當步長是負數(shù)時，從右往左進行鳖眼。

對于正數(shù)步長黑毅，python會從序列的頭部開始向右提取元素，直到最后一個元素钦讳；對于負數(shù)步長矿瘦，則是從序列的尾部開始向左提取元素，直到第一個元素愿卒。正數(shù)步長必須讓開始點小于結(jié)束點缚去，而負數(shù)步長必須讓開始點大于結(jié)束點。

print(number[10:0:-2])
print(number[:5:-2])#這個要注意理解一下
print(number[10:0:-1])#注意number的最大索引應(yīng)該是9琼开，索引10指向的是第11個元素易结，是不存在的。
#但是由于在最后一個元素之后柜候，因此在分片中能得到最后一個元素搞动，這樣做是沒問題的。
#第二個索引為0渣刷，取不到序列中的第一個元素
#print(number[10])#但是直接訪問的話是不可以的
print(number[10::-1])#設(shè)置number的第二個索引為空鹦肿，可以取到序列的一個元素。
print(number[2::-1])#設(shè)置number的第二個索引為空辅柴，可以取到序列的一個元素箩溃。
print(number[2:0:-1])#第二個索引為0高诺，取不到序列中的第一個元素

輸出

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

序列相加

使用加號可以進行序列的連接操作。數(shù)字序列和數(shù)字序列相加后碾篡，得到還是數(shù)字序列虱而。字符串或字符串序列和字符串或字符串序列相加后，得到的還是字符串或字符串序列开泽。但是牡拇，只有類型相同的序列才能通過加號進行序列連接操作，不同類型的序列不能通過加號進行序列連接操作穆律。

#序列相加
a = [1,2,3]
b = [4,5,6]
print(a + b)
c = ["hello"]
d = ["python"]
print(c + d)
e = "hello,"
f = "python"
print(e + f)
print(a + e)

輸出

[1, 2, 3, 4, 5, 6]
['hello', 'python']
hello,python
Traceback (most recent call last):
  File "D:/pyspace/hellopython/HellloWorld.py", line 50, in <module>
    print(a + e)
TypeError: can only concatenate list (not "str") to list

序列乘法

用一個數(shù)字x乘以一個序列會生成新的序列惠呼。在新的序列中，原來的序列將被重復x次峦耘，這就是序列中的乘法剔蹋。

如果要創(chuàng)建一個重復序列，就可以使用序列的乘法快速達到需要的列表辅髓。

#序列的乘法
print("序列的乘法")
print("hello"*5)
print([7]*10)

輸出

序列的乘法
hellohellohellohellohello
[7, 7, 7, 7, 7, 7, 7, 7, 7, 7]

python中可以使用None代表空值泣崩，None是Python的內(nèi)建值，確切的含義是這里什么也沒有洛口。

#空置相乘
aa = [None]*5
print(aa)#長度是5的空置
aa = []*5
print(aa)#只有一個元素是空值矫付，即長度是1的空置

[None, None, None, None, None]
[]

成員資格，in操作符的用法

in運算符用于檢驗某個條件是否為真第焰，并返回檢驗結(jié)果买优，檢驗結(jié)果為真返回True，結(jié)果為假返回False

#成員資格
print("成員資格")
greeting = "hello,world"
print('w' in greeting)
print('a' in greeting)
users = ["C羅","梅西","姆巴佩"]
print("C羅" in users)
print("卡卡" in users)
number = [1,2,3,4,5]
print(1 in number)
print(6 in number)
print(3 in greeting)#數(shù)字類型不能在字符串類型中通過in進行成員資格檢測

成員資格
True
False
True
False
True
False
    print(3 in greeting)
TypeError: 'in <string>' requires string as left operand, not int

長度挺举、最小值和最大值

#長度杀赢、最小值和最大值
print("長度、最小值和最大值")
numbers = [300,200,100,800,500]
print(len(numbers))
print(max(numbers))
print(min(numbers))

輸出

長度湘纵、最小值和最大值
5
800
100

列表

更新列表

元素賦值

通過對元素賦值脂崔，可以更新列表的值≌胺穑可以對列表中的元素賦不同類型的值脱篙。對列表中的元素賦值時，不能超過列表的最大編號

#元素賦值
print("元素賦值")
a = [1,2,3,2,1]
a[1] = 10
print(a)
a[2] = "hello"#可以對列表中的元素賦不同類型的值
print(a)
a[5] = 'abc'#對列表中的元素賦值時伤柄，不能超過列表的最大編號
print(a)

輸出

元素賦值
[1, 10, 3, 2, 1]
[1, 10, 'hello', 2, 1]
    a[5] = 'abc'
IndexError: list assignment index out of range

增加元素

append()方法是一個用于在列表末尾添加新對象的方法绊困。該方法的語法如下：

list.append(obj)

此語法中l(wèi)ist代表列表，obj代表需要添加到list列表末尾的對象

刪除元素

print("刪除元素")
str = ["a","b","c","d","e"]
print(len(str))
del str[0]
print(str)
print(len(str))

輸出

刪除元素
5
['b', 'c', 'd', 'e']
4

分片賦值

可以通過分片賦值直接對列表進行變更适刀。分片賦值不僅能對列表賦值秤朗，還可以使用與原序列不等長的序列將分片替換，并改變列表的長度笔喉。

list()函數(shù)

list()函數(shù)可以直接將字符串轉(zhuǎn)換為列表取视。list()函數(shù)不僅適用于字符串硝皂，所有類型的序列都適用。

#分片賦值
print("分片賦值")
show = list("2018世界杯法國奪冠了")
print(show)
show[7:9] = list("中國")
print(show)
greeting = list("hi")
print(greeting)
greeting[1:] = list("ello")
print(greeting)

輸出

分片賦值
['2', '0', '1', '8', '世', '界', '杯', '法', '國', '奪', '冠', '了']
['2', '0', '1', '8', '世', '界', '杯', '中', '國', '奪', '冠', '了']
['h', 'i']
['h', 'e', 'l', 'l', 'o']

分片賦值可以在不替換任何原有元素的情況下作谭，在任意位置插入新元素稽物。

與append()函數(shù)的區(qū)別，append()函數(shù)只能在末尾增加列表的長度

#分片賦值可以在不替換任何原有元素的情況下折欠，在任意位置插入新元素
field = list("ae")
print(field)
field[1:1] = list("bcd")
print(field)
field2 = list("法國奪冠了")
field2[0:0] = list("2018世界杯")
print(field2)

['a', 'e']
['a', 'b', 'c', 'd', 'e']
['2', '0', '1', '8', '世', '界', '杯', '法', '國', '奪', '冠', '了']

分片賦值同樣支持類似刪除的功能

#分片賦值同樣支持類似刪除的功能
field = list("abcde")
print(field)
field[1:4] = []
print(field)
field2 = list("2018世界杯法國奪冠了")
del field2[0:7]
print(field2)

['a', 'b', 'c', 'd', 'e']
['a', 'e']
['法', '國', '奪', '冠', '了']

嵌套列表

在列表中可以嵌套列表贝或，嵌套的列表取出后還是列表

#嵌套列表
field = list("abc")
print(field)
number = [1,2,3]
mix = [field,number]
print(mix)
print(mix[0])
print(mix[1])

輸出

['a','b','c']
[['a', 'b', 'c'], [1, 2, 3]]
['a', 'b', 'c']
[1, 2, 3]

列表方法

1.append

這個方法前面已經(jīng)講過了，用于在列表末尾增加元素锐秦。格式為

list.append(obj)

2.count

count()方法用于統(tǒng)計某個元素在列表中出現(xiàn)的次數(shù)咪奖。語法如下

list.count(obj)

3.extend

extend()方法用于在列表末尾一次性追加另一個序列中的多個值（用新列表擴展原來的列表）。語法如下：

list.append(seq)

seq代表元素列表

使用序列相加的方法也能達到extend（)方法的效果酱床，但是并沒有改變原來列表的值羊赵，這就是extend()方法和拼接的區(qū)別。

同樣可以使用分片賦值的方法達到同樣的效果扇谣，但是不如extend()方法易于理解

#list方法昧捷，extend()方法
print("list方法，extend()方法")
a = ["hello","world"]
b = ["python","is","funny"]
print(a.extend(b))#extend()方法的返回值是None
print(a)#但是extend()方法改變了列表a的值
a = ["hello","world"]
print(a + b)#a + b的返回值是將a和b做了拼接
print(a)#但是并沒有改變a的值揍堕，這就是extend()方法和拼接的區(qū)別
a[len(a):] = b
print(a)

輸出

list方法料身，extend()方法
None
['hello', 'world', 'python', 'is', 'funny']
['hello', 'world', 'python', 'is', 'funny']
['hello', 'world']
['hello', 'world', 'python', 'is', 'funny']

append與extend的區(qū)別

print("append()與extend()的區(qū)別")
a = ["hello"]
b = ["python","is","funny"]
a.append(b)#將b做為一個列表追加到a中
print(a)
a = ["hello"]
c = "python,is,funny"
a.append(c)#將b做為一個字符串追加到a中
print(a)
a = ["hello"]
a.extend(b)
print(a)#將b中的元素分別追加到a中
a = ["hello"]
c = "python,is,funny"
a.extend(c)
print(a)

輸出

append()與extend()的區(qū)別
['hello', ['python', 'is', 'funny']]
['hello', 'python,is,funny']
['hello', 'python', 'is', 'funny']
['hello', 'p', 'y', 't', 'h', 'o', 'n', ',', 'i', 's', ',', 'f', 'u', 'n', 'n', 'y']

4.index

index()方法，用于返回元素在列表的索引位置衩茸。語法格式如下：

list.index(obj)

#index()方法
print("index()方法")
field = ["hello","world","python","is","funny"]
print(field)
print(field.index("hello"))
print(field.index("python"))
print(field.index("abc"))#不存在時會報錯

index()方法
['hello', 'world', 'python', 'is', 'funny']
0
2
Traceback (most recent call last):
  File "D:/pyspace/hellopython/HellloWorld.py", line 169, in <module>
    print(field.index("abc"))
ValueError: 'abc' is not in list

5.insert

insert()方法用于將對象插入列表。格式如下

list.insert(index,obj)

index代表對象obj需要插入的索引位置贮泞，obj代表插入的對象

#insert()方法
print("insert()方法")
number = [1,2,3]
print(number)
print(number.insert(2,"插入在2之后3之前"))#insert方法并沒有返回值楞慈，而是直接該表了列表的值
print(number)
number = [1,2,3]
number[2:2] = ["插入在2之后3之前"]#使用分片賦值也能實現(xiàn)同樣的功能，但是不如使用insert()方法好理解
print(number)

輸出

insert()方法
[1, 2, 3]
None
[1, 2, '插入在2之后3之前', 3]
[1, 2, '插入在2之后3之前', 3]

6.pop

pop()方法用于移除列表中的一個元素（默認是最后一個元素）啃擦，并且返回該元素的值囊蓝。語法格式為：

list.pop() #默認是移除最后一個元素
list.pop(index) #或者移除指定序列的元素，并且返回指定序列的元素

code

#pop()方法
field = ["hello","world","python","is","funny"]
print(field.pop())
print(field)
print(field.pop(1))
print(field)

輸出

funny
['hello', 'world', 'python', 'is']
world
['hello', 'python', 'is']

7.remove

remove()方法用于移除列表中某個值的第一個匹配項令蛉。語法格式如下

list.remove(obj)

obj為將要remove的元素聚霜。remove返回None值，但是會改變原list的值

#remove()方法
field = ["hello","python","how","funny","python","is"]
print(field.remove("python"))
print(field)#注意只會刪除匹配上的第一個元素

None
['hello', 'how', 'funny', 'python', 'is']

8.reverse

reverse()方法用于方向列表中的元素珠叔。語法格式如下

list.reverse()

code

#reverse()方法
print("reverse()方法")
number = [1,2,3]
print(number.reverse())#注意reverse()方法的返回值是None
print(number)#但是reverse()方法會改變list的值

輸出

reverse()方法
None
[3, 2, 1]

9.sort

sort()方法用于對原列表進行排序蝎宇，如果指定了參數(shù)，就使用參數(shù)指定的比較方法進行排序祷安。語法格式如下

list.sort(func)

sort()方法不會改變返回值（返回None）姥芥，而是直接改變列表的值。

使用sorted()方法汇鞭，則會直接返回列表反轉(zhuǎn)后的結(jié)果

#sort()方法
print("sort()方法")
number = [5,8,7,2,4,3]
print(number.sort())#sort()方法并不會返回值
print(number)#而是直接改變列表的值
print(sorted(number))#使用sorted()方法凉唐，則會直接返回列表反轉(zhuǎn)后的結(jié)果

輸出

sort()方法
None
[2, 3, 4, 5, 7, 8]
[2, 3, 4, 5, 7, 8]

10.clear

clear()方法用于清空列表庸追，類似于del list[:]。語法格式為：

list.clear()

code

#clear()方法
print("clear()方法")
field = ["hello","python","how","funny","python","is"]
field.clear()
print(field)

輸出

clear()方法
[]

11.copy

copy()方法用于復制列表台囱，類似于a[:]淡溯。語法格式為:

list.copy()

code

#copy()方法
print("copy()方法")
field = ["hello","python"]
field2 = field.copy()
print(field2)

輸出

copy()方法
['hello', 'python']

12.高級排序

sort()方法有兩個可選參數(shù)，即key和reverse簿训。key代表關(guān)鍵字血筑，reverse為布爾值，True代表反轉(zhuǎn)煎楣，F(xiàn)alse代表不反轉(zhuǎn)豺总。

#sort()方法
print("sort()方法")
field = ["hello","python","funny","python","is"]
print(field.sort(key=len,reverse=True))
print(field)

輸出

sort()方法
None
['python', 'python', 'hello', 'funny', 'is']

元組

Python的元組于列表相似，不同之處在于元組的元素不能修改择懂。創(chuàng)建元組的方式很簡單喻喳，如果你用逗號分隔了一些值，就會自動創(chuàng)建元組困曙。

1. 定義元組時表伦，加上括號和不加括號的效果是一樣的
2. 但是定義元組時必須得有逗號

#元組
print("元組的定義")
number = 1,2,3
print(number)#這樣打印出的是元組
print(1,2,3)#注意，有意思的是慷丽，這樣打印時蹦哼，打印的并不是一個元組。這樣打印出來的是什么要糊？
number = (1,2,3)#加上括號和不加括號的效果是一樣的
print(number)
field = "hello","world"
print(field)
field = ("hello","world")
print(field)
field = ()
print(field)
field = ("hello",)#定義元組時必須得有逗號
print(field)
field = ("hello")#如果沒有逗號纲熏，則僅僅是一個字符串
print(field)

元組的定義
(1, 2, 3)
1 2 3
(1, 2, 3)
('hello', 'world')
('hello', 'world')
()
('hello',)
hello

tuple函數(shù)

tuple函數(shù)的作用就是以一個序列作為參數(shù)，并把它轉(zhuǎn)換為元組锄俄。這點和list函數(shù)的性質(zhì)基本一樣局劲。如果參數(shù)是元組，則會被原樣返回奶赠。

#tuple函數(shù)
print("tuple函數(shù)")
print(tuple(["hello","python"]))
print(tuple("hello"))
print(tuple(("hello",)))#如果參數(shù)是元組鱼填，則會被原樣返回。

輸出

tuple函數(shù)
('hello', 'python')
('h', 'e', 'l', 'l', 'o')
('hello',)

元組的基本操作

1. 訪問元組

直接使用元素的下標訪問即可毅戈，支持分片

#訪問元組
number = (1,2,3)
print(number)
print(number[0])
print(number[0:2])

輸出

(1, 2, 3)
1
(1, 2)

2. 修改元組

之前說過苹丸，元組是不可以修改的。但是可以對元組進行連接苇经。

#修改元組
number = (1,2,3)
number2 = (4,5,6)
print(number + number2)

輸出

(1, 2, 3, 4, 5, 6)

3. 刪除元組

元組是不可以修改的赘理，因此元組的值當然也是不可以刪除的。但是可以刪除整個元組

#刪除元組
number2 = (1,2,3)
del number2
print(number2)

輸出

Traceback (most recent call last):
  File "D:/pyspace/hellopython/HellloWorld.py", line 263, in <module>
    print(number2)
NameError: name 'number2' is not defined

元組內(nèi)置函數(shù)

1. len(tuple)函數(shù)

2. max()函數(shù)

3. min()函數(shù)

number2 = (1,2,3)
print(len(number2))
#max()函數(shù)
print(max(number2))
#min()函數(shù)
print(min(number2))

輸出

3
3
1

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

嵌套列表

嵌套列表指的是塑陵，一個列表中包含另一個列表感憾，即二維數(shù)組，甚至還有三維、四維等多維數(shù)組阻桅。

t = (1,2,["hello","python"])
print(t[2][1])

輸出

python

列表元組的區(qū)別

區(qū)別在于凉倚，元組的值不可以修改，列表的值可以修改嫂沉。

number2 = (1,2,3)
#number2[1] = 4 #元組的值不可以改變

#嵌套列表
t = (1,2,["hello","python"])
print(t[2][1])
t[2][1] = "world" #元組中列表的值可以改變
print(t)
t[1] = "abc"
print(t) #元組的值不可以改變

輸出

python
(1, 2, ['hello', 'world'])
Traceback (most recent call last):
  File "D:/pyspace/hellopython/HellloWorld.py", line 282, in <module>
    t[1] = "abc"
TypeError: 'tuple' object does not support item assignment

習題

1. 用負數(shù)步長對列表和元組進行分片

#用負數(shù)步長對列表和元組進行分片
number2 = list("123465")
print(number2)
#將列表的順序變?yōu)?23456
#number2[:-3:-1] = ["6","5"] #用分片賦值的方式實現(xiàn)
number2.sort(reverse=False) #用sort()函數(shù)實現(xiàn)
print(number2)
#輸出5,3
print(number2[-2:-5:-2])
number2 = tuple(['1', '2', '3', '4', '5', '6'])
print(number2)
#輸出5,3
print(number2[-2:-5:-2])

輸出

['1', '2', '3', '4', '6', '5']
['1', '2', '3', '4', '5', '6']
['5', '3']
('1', '2', '3', '4', '5', '6')
('5', '3')

2.用索引取出下面list的指定元素

#打印出hello
field = [["hello", "world", "welcome"], ["study", "Python", "is", "funny"], ["good", "better", "best"]]
print(field[0][0])
#打印出Python
print(field[1][1])
#打印出best
print(field[2][2])

輸出

hello
Python
best