大家好呀，今天的內(nèi)容有點(diǎn)多濒析，這一課全面梳理了 Python 的幾種數(shù)據(jù)容器：字符串正什、列表、字典悼枢、元組埠忘、集合的定義、特性以及一些增刪改查的基本操作馒索。之前學(xué)得比較零碎莹妒，或者概念比較混淆的同學(xué)也可以系統(tǒng)地過一遍加深印象、進(jìn)一步理解和區(qū)分這幾種數(shù)據(jù)容器绰上。

一旨怠、字符串（str）

1. 字符串的定義

被單引號(hào)、雙引號(hào)蜈块、三引號(hào)包圍的字符組鉴腻，就是字符串迷扇，例如：

str = 'hello'
str = "world"
str = """hello
            Python"""
#定義多行字符串變量

2. 下標(biāo)和切片

（1）下標(biāo)索引

根據(jù)下標(biāo)找到元素位置，索引從 0 開始：

name = 'zhangsan'
print(name[2])

輸出結(jié)果為a

（2）切片

利用下表索引從字符串里截取一段元素爽哎，切片的語法是: [起始:結(jié)束:步長]蜓席。字符串、列表课锌、元組都支持切片操作厨内。

name = 'abcdef'
print(name[0:3]) 
# 取 下標(biāo)0~2 的字符
運(yùn)行結(jié)果:
abc

name = 'abcdef'
print(name[3:5]) 
# 取 下標(biāo)為3、4 的字符
運(yùn)行結(jié)果 :
de

name = 'abcdef'
print(name[2:]) 
# 取 下標(biāo)為2開始到最后的字符
運(yùn)行結(jié)果:
cdef

同樣支持負(fù)數(shù)：

name = 'abcdef'
print(name[1:-1]) # 取 下標(biāo)為1開始 到 最后第2個(gè)    之間的字符運(yùn)行結(jié)果:
bcde
a = "abcdef" a[:3]
'abc' a[::2]
'ace' a[5:1:2] '' a[1:5:2]
'bd' a[::-2]
'fdb' a[5:1:-2]
'fd'

3. 字符串的增刪改查

假如有字符串 mystr = 'hello world kkb'：

（1）查： ?nd渺贤、index剑按、count庆揩、startswith、endswith瘫筐、r?nd鼠冕、rindex

① find

檢測 str 是否包含在 mystr 中筏养，如果是都弹，返回開始的索引值仁锯，否則返回-1

mystr.find(str, start=0, end=len(mystr))

例如：

mystr = 'hello world kkb' 
mystr.find("kkb")
運(yùn)行結(jié)果為:12
mystr = 'hello world kkb'
mystr.find("kkb",0,10) 
#在mystr字符串0-10下標(biāo)范圍查詢
運(yùn)行結(jié)果:-1

② index

跟 find() 方法一樣，只不過如果 str 不在 mystr 中會(huì)報(bào)一個(gè)異常玻孟。

mystr.index(str, start=0, end=len(mystr))

例如：

mystr = 'hello world kkb' 
mystr.index("ab")
運(yùn)行結(jié)果:控制臺(tái)會(huì)直接報(bào)錯(cuò)(Vale Error:substring not found)

③ count

返回 str 在 start 和 end 之間 在 mystr 里出現(xiàn)的次數(shù)：

mystr.count(str, start=0, end=len(mystr))

例如：

mystr = 'hello world kkb and kkb' 
mystr.count('kkb')
運(yùn)行結(jié)果：2

④ startswith

檢查字符串是否是以 hello 開頭唆缴，是則返回 True ，否則返回 False：

mystr.startswith('hello')

⑤ endswith

檢查字符串是否以 obj 結(jié)束黍翎，如果是返回 True ，否則返回 False：

mystr.endswith(obj)

⑥ r?nd

類似于 find() 函數(shù)艳丛，不過是從右邊開始查找：

mystr.rfind(str, start=0,end=len(mystr))

⑦ rindex

類似于 index() 匣掸，不過是從右邊開始：

mystr.rindex(str, start=0,end=len(mystr))

（2）增

join

mystr 中每個(gè)元素后面插入 str ,構(gòu)造出一個(gè)新的字符串：

str.join(mystr)

（3）刪

① lstrip

刪除 mystr 左邊的空白字符：

mystr.lstrip()

② rstrip

刪除 mystr 字符串末尾的空白字符：

mystr.rstrip()

③ strip

刪除 mystr 字符串兩端的空白字符：

a = "\n\t kkb \t\n" 
a.strip()
運(yùn)行結(jié)果:
'kkb'

（4）改

① replace

把 mystr 中的 str1 替換成 str2，如果 count 指定氮双，則替換不超過 count 次：

mystr.replace(str1, str2, mystr.count(str1))

② split

以 str 為分隔符切片 mystr 碰酝，如果 maxsplit 有指定值，則僅分隔 maxsplit 個(gè)子字符串：

mystr.split(str=" ", 2)

③ capitalize

把字符串的第一個(gè)字符大寫：

mystr.capitalize()

④ title

返回“標(biāo)題化”的字符串戴差，所有單詞都以大寫開始送爸，其余字母均為小寫：

a = "hello kkb" 
a.title()
運(yùn)行結(jié)果
'Hello Kkb'

⑤ lower

轉(zhuǎn)換 mystr 中所有大寫字符為小寫：

mystr.lower()

⑥ upper

轉(zhuǎn)換 mystr 中的小寫字母為大寫：

mystr.upper()

⑦ ljust

返回一個(gè)原字符串左對齊，并使用空格填充至 width 長度的新字符串：

mystr.ljust(width)

⑧ rjust

返回一個(gè)原字符串右對齊暖释，并使用空格填充至長度 width 的新字符串：

mystr.rjust(width)

⑨ center

返回一個(gè)原字符串居中袭厂，并使用空格填充至 width 長度的新字符串：

mystr.center(width)

⑩ partition

把 mystr 以 str 分割成三部分，str 前球匕、str 和 str 后：

mystr.partition(str)

? rpartition

類似于 partition() 函數(shù)纹磺，不過是從右邊開始：

mystr.rpartition(str)

? splitlines

按照行分隔，返回一個(gè)包含各行作為元素的列表：

mystr.splitlines()

二亮曹、列表（list）

1. 列表簡介

列表是一種有序的集合橄杨，可以隨時(shí)添加和刪除其中的元素秘症，寫在方括號(hào)之間、用逗號(hào)分隔開的數(shù)值列表式矫。列表內(nèi)的項(xiàng)目不必全是相同的類型（這點(diǎn)是比C語言的數(shù)組強(qiáng)大的地方）乡摹。

例如：

list1 = ['Mike', '張三', 25000, 99.99, True]

2. 列表的增刪改查

（1）列表的長度

# 用 len() 函數(shù)可以獲得 list 元素的個(gè)數(shù)：
namesList = ['xiaoWang','xiaoZhang','xiaoHua'] 
len(namesList)

（2）列表的訪問

用索引來訪問 list 中每一個(gè)位置的元素，與字符串的索引相同采转，列表的索引也是從0開始的：

namesList = ['Tony','Rose','Lucy'] 
print(namesList[0]) 
print(namesList[1]) 
print(namesList[2]) 

結(jié)果： 
Tony 
Rose 
Lucy

如果索引超出當(dāng)前列表范圍聪廉，例如如果輸入 print(namesList[3])，系統(tǒng)就會(huì)報(bào)錯(cuò)：IndexError: list index out of range氏义。所以锄列，要確保索引不越界，最后一個(gè)元素的索引是 len(classmates) - 1惯悠。

此外邻邮，還可以通過 -1來取最后一個(gè)元素：

namesList = ['Tony','Rose','Lucy'] 
print(namesList[-1])
結(jié)果：
Lucy

以此類推，-2克婶、-3 可以獲取倒數(shù)第2個(gè)筒严、倒數(shù)第3個(gè)元素：

namesList = ['Tony','Rose','Lucy'] 
print(namesList[-1]) 
print(namesList[-2]) 
print(namesList[-3])
結(jié)果：
Lucy 
Rose 
Tony

（3）列表的切片

切片是根據(jù)下標(biāo)的范圍獲取一部分?jǐn)?shù)據(jù)。

切片的使用格式：

數(shù)據(jù)[起始下標(biāo):結(jié)束下標(biāo):步長]

注意：起始下標(biāo)默認(rèn)0情萤， 結(jié)束下標(biāo)是不包含（也就是取左不取右）鸭蛙， 步長默認(rèn)是1

# 使用切片的方式獲取一部分?jǐn)?shù)據(jù)
my_str = ['Mike', '張三', 25000, 99.99, True] 
result = my_str[1:4:1]
print(result)

#前三個(gè)
result = my_str[0:3] 
print(result) 
result = my_str[:3] 
print(result)

（4）添加元素（append、extend筋岛、insert）

通過 append 可以向列表添加元素：

#定義變量A娶视，默認(rèn)有3個(gè)元素
namesListA = ['ZhangSan','LiSi','WangWu']

print("-----添加之前，列表A的數(shù)據(jù)-----")
for tempName in namesListA: 
    print(tempName)

#提示睁宰、并添加元素
temp = input('請輸入要添加的學(xué)生姓名:') 
namesListA.append(temp)

print("-----添加之后肪获，列表A的數(shù)據(jù)-----")
for tempName in namesListA: 
    print(tempName)

通過 extend 可以將另一個(gè)集合中的元素逐一添加到列表中：

#append:
a = [1, 2, 3]
b = [4, 5, 6]
a.append(b) 
print(a)
結(jié)果:
[1, 2, 3, [4, 5, 6]]


#extend:
a = [1, 2, 3]
b = [4, 5, 6]
a.extend(b) 
print(a)
結(jié)果:
[1, 2, 3, 4, 5, 6]

# insert
insert(index, object)` 在指定位置`index`前插入元素`object 
a = [1, 2, 3]
a.insert(1,100) 
print(a)
結(jié)果:
[1, 100, 2, 3]

（5）修改元素

修改元素時(shí)，要通過下標(biāo)來確定要修改哪個(gè)元素柒傻，然后才能進(jìn)行修改：

#定義變量namesListA孝赫，默認(rèn)有4個(gè)元素
namesListA = ['ZhangSan','LiSi','WangWu','ZhaoLiu']

print("-----修改之前，列表A的數(shù)據(jù)-----")
for tempName in namesListA: 
    print(tempName)

# 修改元素 
namesListA[1] = '張三'

print("-----修改之后红符，列表A的數(shù)據(jù)-----")
for tempName in namesListA: 
    print(tempName)

結(jié)果:
-----修改之前青柄，列表A的數(shù)據(jù)-----
ZhangSan 
LiSi 
WangWu 
ZhaoLiu
-----修改之后，列表A的數(shù)據(jù)-----
ZhangSan 
張三
WangWu 
ZhaoLiu

（6）查找元素

所謂的查找预侯，即查找指定元素是否存在致开。

python 中查找的常用方法為：

• in （存在）,如果存在那么結(jié)果為 true ，否則為 false
• not in（不存在）雌桑，如果不存在那么結(jié)果為 true 喇喉，否則 false

#待查找的列表
namesListA = ['ZhangSan','LiSi','WangWu','ZhaoLiu']

#獲取用戶要查找的名字
findName = input('請輸入要查找的姓名:')

#查找是否存在
if findName in namesListA: 
    print('在列表中找到了相同的名字')
else:
    print('沒有找到')

index 和 count 與字符串中的用法相同：

>>> a = ['a', 'b', 'c', 'a', 'b']
>>> a.index('a', 1, 3) # 注意是左閉右開區(qū)間
Traceback (most recent call last): 
    File "<stdin>", line 1, in <module>
ValueError: 'a' is not in list
>>> a.index('a', 1, 4)
3
>>> a.count('b') 
2
>>> a.count('d') 
0

（7）刪除元素

列表元素的常用刪除方法有：

• del： 根據(jù)下標(biāo)進(jìn)行刪除；
• pop：刪除最后一個(gè)元素校坑；
• remove：根據(jù)元素的值進(jìn)行刪除拣技；

① del

list1 = ['a','b','c','d','e','f']

print('------刪除之前------')
for tempName in list1: 
    print(tempName)

del list1[2]

print('------刪除之后------')
for tempName in list1: 
    print(tempName)

結(jié)果:

------刪除之前------
a 
b 
c 
d 
e
f
------刪除之后------
a 
b 
d 
e 
f

② pop

list2 = ['a','b','c','d','e','f']

print('------刪除之前------')
for tempName in list2: 
    print(tempName)

list2.pop()

print('------刪除之后------')
for tempName in list2: 
    print(tempName)

結(jié)果:

------刪除之前------
a 
b 
c 
d 
e 
f
------刪除之后------
a 
b 
c 
d 
e

③ remove

list3 = ['a','b','c','d','e','f']

print('------刪除之前------')
for tempName in list3: 
    print(tempName)

list3.remove('e')

print('------刪除之后------')
for tempName in list3: 
    print(tempName)


結(jié)果:
------刪除之前------
a 
b 
c 
d 
e 
f
------刪除之后------
a 
b 
c 
d 
f

（8）排序 sort

sort 方法是將 list 按特定順序重新排列千诬，默認(rèn)為由小到大，參數(shù) reverse=True 可改為倒序膏斤，由大到小徐绑。reverse 方法是將 list 逆置。

a = [1, 4, 2, 3]
print(a)
結(jié)果:[1, 4, 2, 3]
a.reverse() 
print(a)
結(jié)果:[3, 2, 4, 1]
a.sort() 
print(a)
結(jié)果:[1, 2, 3, 4]
a.sort(reverse=True) 
print(a)
結(jié)果:[4, 3, 2, 1]

3. 列表的遍歷

（1）使用 for 循環(huán)

為了更有效率的輸出列表的每個(gè)數(shù)據(jù)莫辨，可以使用循環(huán)來完成：

namesList = ['ZhangSan','LiSi','WangWu','ZhaoLiu'] 
for name in namesList:
    print(name)

結(jié)果:
ZhangSan 
LiSi 
WangWu 
ZhaoLiu

（2）使用while循環(huán)

namesList = ['ZhangSan','LiSi','WangWu','ZhaoLiu']
length = len(namesList)
i = 0
while i<length: 
    print(namesList[i]) 
    i+=1

結(jié)果:
ZhangSan 
LiSi 
WangWu 
ZhaoLiu

三傲茄、元組（tuple）

元組（tuple）是另一種有序列表，它和 list 非常類似沮榜，但是 tuple 一旦初始化就不能修改盘榨，比如同樣是列出同學(xué)的名字：

>>> classmates = ('Michael', 'Bob', 'Tracy')

現(xiàn)在， classmates 這個(gè) tuple 不能變了蟆融，它也沒有 append() 草巡、 insert() 這樣的方法，不過型酥，其他獲取元素的方法 tuple 和 list 是一樣的山憨，比如還是可以用 classmates[0] 、classmates[-1] 來取值弥喉，但不能賦值成另外的元素郁竟。

tuple 存在的意義在于，由于 tuple 不可變由境，所以代碼更安全棚亩。如果可能，能用 tuple 代替 list 就盡量用 tuple 虏杰。

注意：如果要定義一個(gè)空的 tuple 蔑舞，可以寫成 () ：

>>> t = ()
>>> t ()

但是，要定義一個(gè)只有1個(gè)元素的 tuple 嘹屯，如果你這么定義：

>>> t = (1)
>>> t 1

那么你定義的不是tuple，而是1這個(gè)數(shù)从撼！這是因?yàn)槔ㄌ?hào) () 既可以表示 tuple州弟，又可以表示數(shù)學(xué)公式中的小括號(hào)，這就產(chǎn)生了歧義低零，因此婆翔，Python規(guī)定，這種情況下掏婶，按小括號(hào)進(jìn)行計(jì)算啃奴，計(jì)算結(jié)果自然是1。

所以雄妥，只有1個(gè)元素的tuple定義時(shí)必須加一個(gè)逗號(hào)最蕾，來消除歧義：

>>> t = (1,)
>>> t (1,)

Python在顯示只有1個(gè)元素的 `tuple 時(shí)依溯，也會(huì)加一個(gè)逗號(hào)，以免你誤解成數(shù)學(xué)計(jì)算意義上的括號(hào)瘟则。

最后來看一個(gè)“可變的”tuple：

>>> t = ('a', 'b', ['A', 'B'])
>>> t[2][0] = 'X'
>>> t[2][1] = 'Y'
>>> t
('a', 'b', ['X', 'Y'])

也就是說黎炉，元組中的列表的值是可以改變的。

四醋拧、字典（dict）

1. 字典簡介

字典是另一種可變?nèi)萜髂Ｐ涂妒龋铱纱鎯?chǔ)任意類型對象。字典的每個(gè)鍵值（key=>value）對用冒號(hào) : 分割丹壕，每個(gè)對之間用逗號(hào) , 分割庆械，整個(gè)字典包括在花括號(hào) {} 中。

例如菌赖，要根據(jù)姓名查詢成績缭乘，可以通過一個(gè)姓名-成績對照表：

>>> d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
>>> d['Michael'] 
95

由于一個(gè) key 只能對應(yīng)一個(gè) value ，所以盏袄，多次對一個(gè) key 放入 value忿峻，后面的值會(huì)把前面的值沖掉：

>>> d['Jack'] = 90
>>> d['Jack'] 
90
>>> d['Jack'] = 88
>>> d['Jack'] 
88

如果key不存在，dict 就會(huì)報(bào)錯(cuò)：

>>> d['Thomas']
Traceback (most recent call last): 
    File "<stdin>", line 1, in <module>
KeyError: 'Thomas'

2. 字典的增刪改查

（1）修改元素

字典的每個(gè)元素中的數(shù)據(jù)是可以修改的辕羽，只要通過 key 找到逛尚，即可修改：

info = {'name':'kkb', 'id':100, 'sex':'f', 'address':'中國北京'} 
new_id = input('請輸入新的學(xué)號(hào):')
info['id'] = int(new_id)

print('修改之后的id為: %d' % info['id'])

（2）添加元素

訪問不存在的元素
info = {'name':'kkb', 'sex':'f', 'address':'中國北京'}

print('id為:%d' % info['id'])

結(jié)果:

>>> info = {'name':'kkb', 'sex':'f', 'address':'中國北京'}
>>>
>>> print('id為:%d' % info['id']) 
Traceback (most recent call last):
    File "<stdin>", line 1, in <module> 
KeyError: 'id'

如果在使用 變量名['鍵'] = 數(shù)據(jù) 時(shí)，這個(gè)“鍵”在字典中刁愿，不存在绰寞，那么就會(huì)新增這個(gè)元素。

添加新的元素：

info = {'name':'kkb', 'sex':'f', 'address':'中國北京'}

# print('id為:%d'%info['id'])
#程序會(huì)終端運(yùn)行铣口，因?yàn)樵L問了不存在的鍵
newId = input('請輸入新的學(xué)號(hào)：')
info['id'] = newId
print('添加之后的id為:%d' % info['id'])

結(jié)果:

請輸入新的學(xué)號(hào)：188 
添加之后的id為: 188

（3）刪除元素

對字典進(jìn)行刪除操作滤钱，有以下幾種：

• del
• clear()

① del 刪除指定的元素

info = {'name':'kkb', 'sex':'f', 'address':'中國北京'} 
print('刪除前,%s' % info['name'])
del info['name']
print('刪除后,%s' % info['name'])

結(jié)果
>>> info = {'name':'kkb', 'sex':'f', 'address':'中國北京'}
>>>
>>> print('刪除前,%s' % info['name'])
刪除前,kkb
>>>
>>> del info['name']
>>>
>>> print('刪除后,%s' % info['name']) 
Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
KeyError: 'name'

② del 刪除整個(gè)字典

info = {'name':'monitor', 'sex':'f', 'address':'China'}
print('刪除前,%s' % info) 
del info
print('刪除后,%s' % info)

③ clear 清空整個(gè)字典

info = {'name':'monitor', 'sex':'f', 'address':'China'}
print('清空前,%s' % info) 
info.clear()
print('清空后,%s' % info)

（4）其他操作

① len()
測量字典中，鍵值對的個(gè)數(shù)：

d1 = {'name':'abc','age':'18', 'class':'cnh'} 
print(len(d1))
結(jié)果：
3

② keys
返回一個(gè)包含字典所有key的列表：

d1 = {'name':'abc','age':'18', 'class':'cnh'} 
print(list(d1.keys()))

結(jié)果：
['name', 'age', 'class']

③ values
返回一個(gè)包含字典所有value的列表：

d1 = {'name':'abc','age':'18', 'class':'cnh'} 
print(list(d1.values()))

結(jié)果：
['abc', '18', 'cnh']

④ items
返回一個(gè)包含所有（鍵脑题，值）元祖的列表：

d1 = {'name':'abc','age':'18', 'class':'cnh'} 
print(list(d1.items()))

結(jié)果：
[('name', 'abc'), ('age', '18'), ('class', 'cnh')]

5件缸、集合（set）

集合（set）是一個(gè)無序的不重復(fù)元素序列∈逅欤可以使用大括號(hào) { } 或者 set() 函數(shù)創(chuàng)建集合他炊。

注意：

（1）創(chuàng)建一個(gè)空集合必須用 set() 而不是 { }，因?yàn)?{ } 是用來創(chuàng)建一個(gè)空字典已艰。
（2）集合不支持下標(biāo)賦值和取值痊末，因?yàn)榧显貨]有順序，因此沒有序列的概念哩掺。

my_set = {1, 4, 'abc', 'hello'} 

#通過遍歷獲取數(shù)據(jù)
my_set = {1, 5, 7} 
for value in my_set:
    print(value)

for index,value in enumerate(my_set): 
    print(index,value)

# 定義空的集合的時(shí)候不能直接使用{}
my_set = set() 
my_set.add(1) 
my_set.add(1) 
print(my_set, type(my_set))
# 這里 my_set 仍然只有一個(gè)元素1凿叠，因?yàn)榧显夭荒苤貜?fù)。

# 集合可以對容器類型數(shù)據(jù)去重
my_list = [1, 1, 3, 5, 3] 
# 把列表轉(zhuǎn)成集合，會(huì)把數(shù)據(jù)去重
my_set = set(my_list)
print(my_set)
# 輸出結(jié)果為 {1, 3, 5}

# 列表盒件，元組蹬碧， 集合 三者之間可以相互轉(zhuǎn)換
my_tuple = (5, 3)
my_tuple = set(my_tuple)
print(my_tuple, type(my_tuple))
# 輸出結(jié)果為 {3, 5} <class 'set'>