Python3——內置數據結構:list 、tuple

內置數據結構（變量類型）

• list
• set （詳見 python-數據類型）
• dict （詳見 python-數據類型）
• tuple

list（列表）

• 一組有順序的數字的組合
• 創建列表
  • 空列表

l1=[]   #創建一個空列表  
print(type(l1))
print(l1)
l2=[100]  #創建一個帶值得列表
print(type(l2))
print(l2)
l3=[2,5,5,8,1,3]   #創建帶多個值得列表
print(type(l3))
print(l3)
l4=list()   #創建一個空列表
print(type(l4))
print(l4)



運行結果：
<class 'list'>
[]
<class 'list'>
[100]
<class 'list'>
[2, 5, 5, 8, 1, 3]
<class 'list'>
[]
Process finished with exit code 0

列表常用操作1

• 訪問
  • 使用下標操作（索引）
  • 列表的位置是從0開始的（規定列表最後一個下標爲 -1）
• 分片操作
  • 對列表進行任意一段的截取
  • list [ : ] (截取範圍是從冒號前到冒號後，但是冒號後的數字取不到）
    （冒號前後可以爲空，前爲空表示從位置0開始，後爲空表示截止最大數加一，即截取到最後一個數據）
  • list [ : : ] （第二個冒號表示增長幅度，默認增長幅度爲1，即一個一個增長，如果此數爲負值，則表示順序爲從右往左）

#下標訪問列表
l=[2,3,5,4,1,6]
print(l)
print(l[4])  #提取下標數字
print(l[2:4])   #提取從下標二到下標三
print(l[ :5])  #提取從第一個到下標四
print(l[2:])  #提取從下標二到最後一個
print(l[ : :2])  #從第一個到最後一個間隔爲2
print(l[-2:-5])  #下面顯示爲空是因爲分片默認順序是從左往右，正常情況下冒號左邊的數要小於右邊的數
print(l[-5:-2])
print(l[-2:-5:-1])  #如果非要這麼寫，則需要吧步長寫爲負數，但是截取的結果也是顛倒的



運行結果：
[2, 3, 5, 4, 1, 6]
1    #提取下標數字
[5, 4]    #提取從下標二到下標三
[2, 3, 5, 4, 1]    #提取從第一個到下標四
[5, 4, 1, 6]   #提取從下標二到最後一個
[2, 5, 1]    #從第一個到最後一個間隔爲2
[]
[3, 5, 4]
[1, 4, 5]
Process finished with exit code 0

分片操作是生成一個新的list

• 內置函數id，負責顯示一個變量或者數據的唯一確定編號

l=[2,5,3,8,4,6]
ll=l[:]
l[1]=100
#l 和 ll 不是同一個列表
print(id(l))
print(id(ll))
print(l)
print(ll)



運行結果：
287737405960
287737406024
[2, 100, 3, 8, 4, 6]
[2, 5, 3, 8, 4, 6]
Process finished with exit code 0

list（列表）操作2

• del 刪除命令
  • del一個變量後，此變量將無法在使用

#del案例
l=[2,5,3,8,4,6]
print(id(l))
del l[2]
print(id(l))
print(l)



運行結果：
770037604872
770037604872    #運行del函數後不會形成一個新的list，仍然是原來那個
[2, 5, 8, 4, 6]
Process finished with exit code 0

• 列表相加
  • 使用加號連接兩個列表

#列表相加案例
a=[1,2,3,4]
b=[5,6,8]
c=['a', 'b', 'c']
d=a+b+c
print(d)



運行結果：
[1, 2, 3, 4, 5, 6, 8, 'a', 'b', 'c']
Process finished with exit code 0

• 列表數乘
  • 列表直接跟整數相乘，相當於把n個列表連在一起

#列表數乘案例
a=[1,2,3,4]
b=a*3
print(b)



運行結果：
[1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4]
Process finished with exit code 0

• 成員資格運算
  • 就是判斷一個元素是否在list中

a=[1,2,3,4]
b=3
c=b in a
print(c)



運行結果：
True

• 列表的遍歷
  • for
  • while （一般不用while訪問列表）

#列表遍歷案例：
a=[1,2,3,4]
for i in a:
    print(i)
b=['i love sunyue']
for i in b:
    print(i)
print("#"*20)


#以下是while用法
l=len(a)
n=0  #n表示列表的下標
while n<l:
    print(a[n])
    n += 1



運行結果：
1
2
3
4
i love sunyue
####################
1
2
3
4
Process finished with exit code 0

• 雙層列表循環

#a爲嵌套列表，又稱雙層列表
a=[["one",1],["two",2],["three",3]]
for k,v in a:
    print(k,"---",v)



運行結果：
one --- 1
two --- 2
three --- 3
Process finished with exit code 0

列表內涵：list content

• 通過簡單方法創建列表

#用for創建
a=[x for x in range(1,6 )]
b=[i for i in a]  #對於a中得每一個元素，逐個放入到b中
print(b)
c=[i*10 for i in a]   #將a中得每一個元素乘10 ，再逐個放入到c中
print(c)
d=[m for m in a if m % 2 ==0]   #過濾：將a中得偶數提取出來放到d中
print(d)
f=[m+n for m in a for n in b]   #相當於兩個for循環嵌套，且同樣可以使用條件表達式
print(f)



運行結果：
[1, 2, 3, 4, 5]
[10, 20, 30, 40, 50]
[2, 4]
[2, 3, 4, 5, 6, 3, 4, 5, 6, 7, 4, 5, 6, 7, 8, 5, 6, 7, 8, 9, 6, 7, 8, 9, 10]
Process finished with exit code 0

• 一些題外話

#傳值和傳址的區別
#對於簡單的數值，採用傳值操作，即在函數內對參數的操作不影響外面的變量
#對於複雜變量，採用的是傳地址操作，此時函數內的和外面的數據是同一份，不管在哪裏更改都會影響其內容
def a(n):
    n[2]=300
    print (n)
    return None

def b(n):
    n += 100
    print (n)
    return None

an=[1,2,3,4,5,6,7]
bn=9

print(an)
a(an)  #傳址，會對其中的數值進行修改
print(an)

print(bn)
b(bn)   #傳值，只會改變傳過來的數據，但不會改變原始數據
print (bn)



運行結果：
[1, 2, 3, 4, 5, 6, 7]
[1, 2, 300, 4, 5, 6, 7]
[1, 2, 300, 4, 5, 6, 7]
9
109
9

關於列表的函數

len（）: 表示列表的長度

cmp（list1，list2）:比較兩個列表的元素

max（）: 表示列表中的最大值（同理還有min）

list（）：將其他形式的數據轉換爲list（前提是可以轉換）

zip()：將序列中的元素按照順序進行配對組成一個元組，然後將這些元組放到新的序列當中。

• zip()函數返回的是zip類型，需要用list()函數進行轉換

names = ['吳承恩', '羅貫中', '施耐庵', '曹雪芹']
books = ['西遊記', '三國演義', '水滸傳', '紅樓夢']
times = ['1501年-1582年', '1330年—1400年', '1296年—1370年', '1715年-1763年']
books_info = zip(names, books, times)
print(list(books_info))

# 輸出：[('吳承恩', '西遊記', '1501年-1582年'), ('羅貫中', '三國演義', '1330年—1400年'), ('施耐庵', '水滸傳', '1296年—1370年'), ('曹雪芹', '紅樓夢', '1715年-1763年')]

append（）: 表示插入一個內容，在末尾追加

sort（）：將列表元素排序

index（x）：返回第一次出現x元素的索引值

a = [i for i in range(1,5)]
print(a)
a.append(100)
print(a)



運行結果：
[1,2,3,4]
[1,2,3,4,100]

insert（）: 表示指定位置插入

括號中需要定義兩個值，一個表示位置下標，一個表示插入值
insert（index，data）插入的值是index的前面

a = [i for i in range(1,5)]
print(a)
a.insert(2,50)
print(a)



運行結果：
[1, 2, 3, 4]
[1, 2, 50, 3, 4]

del 刪除：它是根據索引(元素所在位置)來刪除

str=[1,2,3,4,5,2,6]
del str[1]	#刪除下標爲1的元素
print(str)
[1, 3, 4, 5, 2, 6]

str=[0,1,2,3,4,5,6]
del str[2:4] #刪除從第2個元素開始，到第4個爲止的元素(但是不包括尾部元素)
print(str)
[0, 1, 4, 5, 6]

pop（）：從隊尾拿出一個元素，即吧最後一個元素取出來，括號裏也可以輸入指定下標

remove（x）:在列表中刪除第一次出現的元素x

clear():清空

#列表的刪除實例
a = [i for i in range(1,10)]
print(a)
print(id(a))

#pop刪除實例
last_del=a.pop()   #通常pop用於賦值
print("提取出來的值爲：",last_del)
print(a)
print(id(a))   #id一樣，說明是同一個列表
b = a.pop(6)
print("提取出來下標爲6的值爲：",b)
print(a)
print(id(a))

#remove刪除實例
a.remove(2)   #刪除a中數值爲2的元素
print(a)
print(id(a))   #id一樣，說明是同一個列表

#clear清空實例
a.clear()   #清空一個列表
print(a)
print(id(a))   #id一樣，說明是同一個列表



運行結果：
[1, 2, 3, 4, 5, 6, 7, 8, 9]
722993177096
提取出來的值爲： 9
[1, 2, 3, 4, 5, 6, 7, 8]
722993177096
提取出來下標爲6的值爲： 7
[1, 2, 3, 4, 5, 6, 8]
722993177096
[1, 3, 4, 5, 6, 8]
722993177096
[]
722993177096

reverse 翻轉列表內容

#列表的翻轉實例
a = [i for i in range (1,10)]
print(a)
print(id(a))
a.reverse()
print(a)
print(id(a))    #id一樣，說明是同一個列表



運行結果：
[1, 2, 3, 4, 5, 6, 7, 8, 9]
292435288584
[9, 8, 7, 6, 5, 4, 3, 2, 1]
292435288584

extend 擴展列表，將兩個列表中的一個直接拼接到另一個的後面

#列表的擴展實例
a = [i for i in range (1,10)]
b = [i for i in range (10,15)]
print(a)
print(id(a))
a.extend(b)
print(a)
print(id(a))



運行結果：
[1, 2, 3, 4, 5, 6, 7, 8, 9]
62002192904
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
62002192904

count 查找列表中指定值或者元素的個數

#列表的count實例
a = [1,2,5,3,5,4,5,1,2,1]
print(a)
print(id(a))
n= int(input("請輸入數字："))   #input輸入的是字符，需要轉換爲int類型
b = a.count(n)
print("列表中{}的個數爲：".format(n),b)



運行結果：
[1, 2, 5, 3, 5, 4, 5, 1, 2, 1]
637753188872
請輸入數字：5
列表中5的個數爲： 3

copy 拷貝， 淺拷貝

a = [1,2,3,4,5]
print(a)
b = a   #list類型，簡單賦值操作，是傳地址
b[3] = 77
print("更改b的值後a的值爲：",a)
print("a的ID地址爲：",id(a))
print("更改b的值後b的值爲：",b)
print("b的ID地址爲：",id(b))
print("*"*20)
#拷貝實例
b = a.copy()
print("a的值爲：",a)
print("a的ID地址爲：",id(a))
print("b的值爲：",b)
print("b的ID地址爲：",id(b))  #copy之後ID地址發生改變
print("*"*20)
b[3] = 88
print("更改b的值後a的值爲：",a)
print("更改b的值後b的值爲：",b)



運行結果：
[1, 2, 3, 4, 5]
更改b的值後a的值爲： [1, 2, 3, 77, 5]
a的ID地址爲： 33841672
更改b的值後b的值爲： [1, 2, 3, 77, 5]
b的ID地址爲： 33841672
********************
a的值爲： [1, 2, 3, 77, 5]
a的ID地址爲： 33841672
b的值爲： [1, 2, 3, 77, 5]
b的ID地址爲： 34328264
********************
更改b的值後a的值爲： [1, 2, 3, 77, 5]
更改b的值後b的值爲： [1, 2, 3, 88, 5]

• 深拷貝和淺拷貝的區別
• 深拷貝需要特定的工具

a0 = [10,20,30]
a = [1,2,3,a0]
b = a.copy()
print(id(a[3]))
print(id(b[3]))  #拷貝以後b中a0的地址沒有發生變化
a[3][2] = 666
#淺拷貝，只拷貝一層內容
#也就是說，b拷貝的是a，而b中的a0還是指向原地址，所以改變b中a0的值後，a中a0的值也發生改變
print(a)
print(b)



運行結果：
4809224
4809224
[1, 2, 3, [10, 20, 666]]
[1, 2, 3, [10, 20, 666]]

元組-tuple

• 元組可以看成是一個不可更改的list
• tuple寫在一個小括號裏，元素之間用逗號隔開。
• 元組的元素不可變，但是可以包含可變對象，如list。
• 元組可以用作字典的鍵，也可以作爲集合的元素，但是列表就不可以，包含列表的元組也不可以。

元組創建

#創建空元組
t = ()
print(type(t))
<class 'tuple'>
#創建一個只有一個值的元組
t = (1,)
print(type(t))
print(t)
<class 'tuple'>
(1,)

t = 1,
print(type(t))
print(t)
<class 'tuple'>
(1,)

# 創建多個值得元組
t = 1,2,3,4,5
print(type(t))
print(t)
<class 'tuple'>
(1, 2, 3, 4, 5)

#使用其他結構創建
l = [1,2,3,4]
t = tuple(l)
print(type(t))
print(t)
<class 'tuple'>
(1, 2, 3, 4)

元組的特性

• 是序列表，有序
• 元組數據值可以訪問，不能修改
• 元組數據可以是任意類型
• 總之，list所有特性，除了可修改，元組都具有。 也就意味着，list具有的一些操作，比如索引，分片，序列相加，相乘，成員資格操作等都一模一樣

生成器表達式

gen = (2**i for i in range(8))  #創建一個生成器對象
#生成器使用一次後就用完了，之後再次使用就是空的
print(gen)
print((gen)) #轉換爲列表
print(tuple(gen))


gen = (2**i for i in range(8))
print(next(gen))    #使用next（）函數訪問下一個元素
print(next(gen))
for item in gen:    #使用for循環訪問剩下的所有元素
    print(item,end = ' ')


gen的輸出結果爲： <generator object <genexpr> at 0x000001D43FF88E48>
list(gen)的輸出結果爲： [1, 2, 4, 8, 16, 32, 64, 128]
tuple(gen)的輸出結果爲： ()
第一次結果爲： 1
第二次結果爲： 2
剩餘所有結果爲：
4 8 16 32 64 128