資料結構

序列

序列是Python中最基本的一種資料結構，資料結構指計算機中資料儲存的方式，序列用於儲存一組有序的資料，所有的資料在序列當中都有一個唯一的位置（索引），並且序列中的資料會按照新增的順序來分配索引
序列的分類
可變序列（序列中的元素可以改變）

• 列表（list）

不可變序列（序列中的元素不能改變）

• 字串（str）
• 元組（tuple）
• 集合（set）

可變物件
每個物件中都儲存了三個資料

• id（標識）
• type（型別）
• value（值）

列表就是一個可變物件
a = [1,2,3]
a[0] = 10 （改物件）

1. 這個操作是在通過變數去修改物件的值
2. 這種操作不會改變變數所指向的物件
3. 當我們去修改物件時，如果有其他變數也指向了該物件，則修改也會在其他的變數中體現

a = [4,5,6] （改變數）

1. 這個操作是在給變數重新賦值
2. 這種操作會改變變數所指向的物件
3. 為一個變數重新賦值時，不會影響其他的變數
4. 一般只有在為變數賦值時才是修改變數，其餘的都是修改物件

列表

列表是Python中的一個用來儲存物件的物件，物件是記憶體中專門用來儲存資料的一塊區域，數值只能儲存一個單一的資料，列表中可以儲存多個有序的資料

基本使用

1.建立列表，通過[]來建立列表

my_list = [] 建立了一個空列表

2.列表儲存的資料，我們稱為元素，一個列表中可以儲存多個元素，也可以在建立列表時，來指定列表中的元素

my_list = [10] 建立一個只包含一個元素的列表

3.當向列表中新增多個元素時，多個元素之間使用,隔開

my_list = [10,20,30,40,50] 建立了一個包含5個元素的列表

4.列表中可以儲存任意的物件

my_list = [10,'hello',True,None,[1,2,3],print]

5.通過索引獲取列表中的元素
列表中的物件都會按照插入的順序儲存到列表中，第一個插入的物件儲存到第一個位置，第二個儲存到第二個位置，我們可以通過索引（index）來獲取列表中的元素，索引是元素在列表中的位置，列表中的每一個元素都有一個索引，索引是從0開始的整數，列表第一個位置索引為0，第二個位置索引為1，第三個位置索引為2，以此類推，列表的索引也可以是負數，如果索引是負數，則從後向前獲取元素，-1表示倒數第一個，-2表示倒數第二個，以此類推
list[索引]
如果使用的索引超過了最大的範圍，會丟擲異常，IndexError: list index out
of range

切片

切片指從現有列表中，獲取一個子列表
1.通過切片來獲取指定的元素
2.語法：列表[起始:結束:步長]

1. 通過切片獲取元素時，會包括起始位置的元素，不會包括結束位置的元素
2. 做切片操作時，總會返回一個新的列表，不會影響原來的列表
3. 起始和結束位置的索引都可以省略不寫
4. 如果省略結束位置，則會一直擷取到最後
5. 如果省略起始位置，則會從第一個元素開始擷取
6. 如果起始位置和結束位置全部省略，則相當於建立了一個列表的副本
7. 步長表示，每次獲取元素的間隔，預設值是1
8. 步長不能是0，可以是負數，如果是負數，則會從列表的後部向前邊取元素

函式

+和*

1. +可以將兩個列表拼接為一個列表
2. *可以將列表重複指定的次數

in和not in

1. in用來檢查指定元素是否存在於列表中,如果存在，返回True，否則返回False
2. not in用來檢查指定元素是否不在列表中,如果不在，返回True，否則返回False

len()

獲取列表中的元素的個數，獲取到的長度的值，是列表的最大索引+1

min()

獲取列表中的最小值

max()

獲取列表中的最大值

list.index('xx', x, x)

獲取指定元素在列表中的第一次出現時索引，index()的第二個引數，表示查詢的起始位置，第三個引數，表示查詢的結束位置

list.count('xx')

統計指定元素在列表中出現的次數
方法和函式基本上是一樣，只不過方法必須通過物件.方法()的形式呼叫

通過索引來修改元素

stus[0] = 'sunwukong'

通過del來刪除元素

del stus[2]

通過切片來修改列表

在給切片進行賦值時，只能使用序列
stus[0:2] = ['牛魔王','紅孩兒']
使用新的元素替換舊元素
stus[0:2] = ['牛魔王','紅孩兒','二郎神']
stus[0:0] = ['牛魔王']
向索引為0的位置插入元素
當設定了步長時，序列中元素的個數必須和切片中元素的個數一致
stus[::2] = ['牛魔王','紅孩兒','二郎神']

通過切片來刪除元素

del stus[0:2]
del stus[::2]
以上操作，只適用於可變序列，可以通過list()函式將其他的序列轉換為list

方法

append()

向列表的最後新增一個元素

insert()

向列表的指定位置插入一個元素
引數：
1.要插入的位置
2.要插入的元素
stus.insert(x, 'xx')

extend()

使用新的序列來擴充套件當前序列，需要一個序列作為引數，它會將該序列中的元素新增到當前列表中
stus.extend(x)

clear()

清空序列

pop()

根據索引刪除並返回被刪除的元素
result = list.pop(2)
刪除索引為2的元素
result = list.pop()
刪除最後一個

remove()

刪除指定值的元素，如果相同值得元素有多個，只會刪除第一個

reverse()

用來反轉列表
stus.reverse()

sort()

用來對列表中的元素進行排序，預設是升序排列，如果需要降序排列，則需要傳遞一個reverse=True作為引數

遍歷列表

通過for迴圈來遍歷列表

語法：
 for 變數 in 序列 :
 程式碼塊

for迴圈的程式碼塊會執行多次，序列中有幾個元素就會執行幾次，每執行一次就會將序列中的一個元素賦值給變數，所以我們可以通過變數，來獲取列表中的元素

元組

元組是一個不可變的序列，它的操作的方式基本上和列表是一致的

基本使用

1.建立元組,使用()來建立元組

my_tuple = (), 建立了一個空元組

2.建立了一個5個元素的元組

my_tuple = (1,2,3,4,5)

元組是不可變物件，不能嘗試為元組中的元素重新賦值
當元組不是空元組時，括號可以省略，如果元組不是空元組，它裡邊至少要有一個

my_tuple = 10,20,30,40
my_tuple = 40,
my_tuple = 10 , 20 , 30 , 40

解包

解包指就是將元組當中每一個元素都賦值給一個變數

a,b,c,d = my_tuple

交換a和b的值，這時我們就可以利用元組的解包

a , b = b , a
my_tuple = 10 , 20 , 30 , 40

在對一個元組進行解包時，變數的數量必須和元組中的元素的數量一致，也可以在變數前邊新增一個*，這樣變數將會獲取元組中所有剩餘的元素

a , b , \*c = my_tuple
a , \*b , c = my_tuple
\*a , b , c = my_tuple
a , b , \*c = [1,2,3,4,5,6,7]
a , b , \*c = 'hello world'

不能同時出現兩個或以上的*變數
== != is is not
== != 比較的是物件的值是否相等
is is not 比較的是物件的id是否相等（比較兩個物件是否是同一個物件）

字典

1.字典屬於一種新的資料結構，稱為對映（mapping），字典的作用和列表類似，都是用來儲存物件的容器，列表儲存資料的效能很好，但是查詢資料的效能的很差
在字典中每一個元素都有一個唯一的名字，通過這個唯一的名字可以快速的查詢到指定的元素，在查詢元素時，字典的效率是非常快的
2.在字典中可以儲存多個物件，每個物件都會有一個唯一的名字，這個唯一的名字，我們稱其為鍵（key），通過key可以快速的查詢value，這個物件，我們稱其為值（value），所以字典，我們也稱為叫做鍵值對（key-value）結構，每個字典中都可以有多個鍵值對，而每一個鍵值對我們稱其為一項（item）

基本使用

使用{}來建立字典

d = {}
建立了一個空字典
建立一個包含資料的字典
語法：

{key:value,key:value,key:value}

字典的值可以是任意物件
字典的鍵可以是任意的不可變物件（int、str、bool、tuple ...），但是一般我們都會使用str
字典的鍵是不能重複的，如果出現重複的後邊的#### 會替換到前邊的

使用 dict()函式來建立字典

每一個引數都是一個鍵值對（這種方式建立的字典，key都是字串）
d = dict(name='孫悟空',age=18,gender='男')
也可以將一個包含有雙值子序列的序列轉換為字典
雙值序列，序列中只有兩個值，[1,2] ('a',3) 'ab'
子序列，如果序列中的元素也是序列，那麼我們就稱這個元素為子序列
d = dict([('name','孫悟飯'),('age',18)])

根據鍵來獲取值

語法：d[key]
通過[]來獲取值時，如果鍵不存在，會丟擲異常 KeyError
get(key[, default]) 該方法用來根據鍵來獲取字典中的值，如果獲取的鍵在字典中不存在，會返回None，也可以指定一個預設值，來作為第二個引數，這樣獲取不到值時將會返回預設值
修改字典
d[key] = value 如果key存在則覆蓋，不存在則新增
setdefault(key[, default]) 可以用來向字典中新增key-value
如果key已經存在於字典中，則返回key的值，不會對字典做任何操作
如果key不存在，則向字典中新增這個key，並設定value

常用方法

in

檢查字典中是否包含指定的鍵

not in

檢查字典中是否不包含指定的鍵

len()

獲取字典中鍵值對的個數

update([other])

將其他的字典中的key-value新增到當前字典中,如果有重複的key，則後邊的會替換到當前的

d = {'a':1,'b':2,'c':3}
d2 = {'d':4,'e':5,'f':6, 'a':7}
d.update(d2)

del d['key']

刪除，可以使用del來刪除字典中的key-value

popitem()

隨機刪除字典中的一個鍵值對，一般都會刪除最後一個鍵值對
刪除之後，它會將刪除的key-value作為返回值返回,返回的是一個元組，元組中有兩個元素，第一個元素是刪除的key，第二個是刪除的value
當使用popitem()刪除一個空字典時，會丟擲異常KeyError:'popitem():dictionary is empty'

pop(key[, default])

根據key刪除字典中的key-value，會將被刪除的value返回
如果刪除不存在的key，會丟擲異常
如果指定了預設值，再刪除不存在的key時，不會報錯，而是直接返回預設值

result = d.pop('d')
result = d.pop('z','這是預設值')

clear()

用來清空字典

d.clear()

copy()

該方法用於對字典進行淺複製
複製以後的物件，和原物件是獨立，修改一個不會影響另一個
注意，淺複製會簡單複製物件內部的值，如果值也是一個可變物件，這個可變物件不會被複制

d = {'a':1,'b':2,'c':3}
d2 = d.copy()
d = {'a':{'name':'孫悟空','age':18},'b':2,'c':3}
d2 = d.copy()

遍歷字典

keys()

該方法會返回一個序列，序列中儲存有字典的所有的鍵
通過遍歷keys()來獲取所有的鍵

for k in d.keys() :
 print(k , d[k])

values()

該方法會返回一個序列，序列中儲存有字典的所有的值

for v in d.values():
 print(v)

items()

該方法會返回字典中所有的項,它會返回一個序列，序列中包含有雙值子序列
雙值分別是，字典中的key和value

for k,v in d.items() :
 print(k , '=' , v)

集合

集合和列表非常相似
不同點：

1. 集合中只能儲存不可變物件
2. 集合中儲存的物件是無序
3. 集合中不能出現重複的元素

基本使用

使用{}來建立集合

s = {10,3,5,1,2,1,2,3,1,1,1,1}
s = {[1,2,3],[4,6,7]} TypeError: unhashable type: 'list'

使用 set()函式來建立集合

s = set()空集合
可以通過set()來將序列和字典轉換為集合
s = set([1,2,3,4,5,1,1,2,3,4,5])
s = set('hello')
s = set({'a':1,'b':2,'c':3}) 使用set()將字典轉換為集合時，只會包含字典中的鍵

常用方法

• 使用in和not in來檢查集合中的元素
• 使用len()來獲取集合中元素的數量
• add() 向集合中新增元素
• update() 將一個集合中的元素新增到當前集合中，update()可以傳遞序列或字典作為引數，字典只會使用鍵

s2 = set('hello')
s.update(s2)
s.update((10,20,30,40,50))
s.update({10:'ab',20:'bc',100:'cd',1000:'ef'})

• pop() 隨機刪除並返回一個集合中的元素

result = s.pop()

• remove() 刪除集合中的指定元素

s.remove(x)

• clear()清空集合
• copy() 對集合進行淺複製

集合運算

建立兩個集合
s = {1,2,3,4,5}
s2 = {3,4,5,6,7}

& 交集

result = s & s2 {3, 4, 5}

| 並集

result = s | s2 {1,2,3,4,5,6,7}

- 差集

result = s - s2 {1, 2}

^ 異或集

result = s ^ s2 {1, 2, 6, 7}

>=/<= 超/子集

如果a集合中的元素全部都在b集合中出現，那麼a集合就是b集合的子集，b集合是a集合超集
a = {1,2,3}
b = {1,2,3,4,5}
result = a <= b True
result = {1,2,3} <= {1,2,3} True
result = {1,2,3,4,5} <= {1,2,3} False

>/< 真超/子集

如果超集b中含有子集a中所有元素，並且b中還有a中沒有的元素，則b就是a的真超集，a是b的真子集
result = {1,2,3} < {1,2,3} False
result = {1,2,3} < {1,2,3,4,5} True