13518219792
? Python 的基礎(chǔ)數(shù)據(jù)結(jié)構(gòu)有：列表( list ), 元祖( tuple ), 字典( dict ), 字符串( string ), 集合( set )等，區(qū)別聯(lián)系如下：
潁州網(wǎng)站制作公司哪家好，找創(chuàng)新互聯(lián)建站！從網(wǎng)頁設(shè)計、網(wǎng)站建設(shè)、微信開發(fā)、APP開發(fā)、成都響應(yīng)式網(wǎng)站建設(shè)公司等網(wǎng)站項目制作，到程序開發(fā)，運(yùn)營維護(hù)。創(chuàng)新互聯(lián)建站自2013年創(chuàng)立以來到現(xiàn)在10年的時間，我們擁有了豐富的建站經(jīng)驗和運(yùn)維經(jīng)驗，來保證我們的工作的順利進(jìn)行。專注于網(wǎng)站建設(shè)就選創(chuàng)新互聯(lián)建站。
? 列表[]、元組()和字符串 都是 序列 ，字符串是字符的序列， 列表和元祖 是 任意類型 的序列
注： 本博主csdn同步鏈接
[1]. python列表(list)、元祖(tuple)、集合(set)，和字典(dictionary)的比較
[2]. Python學(xué)習(xí)筆記(四)—列表(list)、元組(tuple)和字典(dictionary)、集合(set)
[3]. Python學(xué)習(xí)筆記(四)—列表(list)、元組(tuple)和字典(dictionary)、集合(set)
一：元組(tuple)
1、元組是不可改變的序列，同list一樣，元組可以存放任意類型的元素，一旦元組生成，則它不可以改變（包括增、刪、改）。
2、元組的表示方式：用小括號（）括起來，單個元素括起來用逗號（，）區(qū)分是單個對象還是元組
3、元組的創(chuàng)建：
創(chuàng)建空元組的字符值：t=()
創(chuàng)建非空元組的字面值：
t=200,
t=(20,)
t=(1,2,3)
t=100,200,300
4、元組的構(gòu)造函數(shù)（tuple）
A:tuple()生成一個空的元組，等同于()
B:tuple(iterable)用可迭代對象生成一個元組
示例：
t=tuple()
t=tuple(range(10))
t=tuple(‘hello’)
t=tuple([])
二：元組的用法
1、元組的算術(shù)運(yùn)算：（用法與列表的用法完全相同）
+=**=
例：定義兩個元組，與其相加，再用得到的新元組乘以2，與列表對比一下，看看有何不同？（分析：兩原組相加，會把第二個元組的元素放在第一個元組元素的后面，兩元組相乘，會重復(fù)原元組元素的個數(shù)，乘以幾，就重復(fù)幾次）
2、元組的比較運(yùn)算：
====!=
3、in/not in
索引取值
切片取值
規(guī)則與列表完全相同
區(qū)別：
元組是不可變對象，不支持索引賦值和切片賦值
4、元組的方法
t.index(v[,begin[,end]])----用于獲取元組中V所在的索引位置
t.count(v)----用于獲取元組中V的個數(shù)
例：定義一個元組字面值，查看某個值在元組的索引位置，并統(tǒng)計其元組中某個數(shù)出現(xiàn)的個數(shù)。
5、元組中的三個構(gòu)造函數(shù)和序列函數(shù)
Str(obj)
List(iterable)
Tuple(iterable)
序列函數(shù)：len,max,min,sum,all,any
1、列表（list）
list是處理一組有序項目的數(shù)據(jù)結(jié)構(gòu)，即你可以在一個列表中存儲一個序列的項目。
列表中的項目應(yīng)該包括在方括號中，這樣Python就知道你是指明一個列表。一旦你創(chuàng)建了一個列表，就可以添加、刪除，或者是搜索列表中的項目。由于你可以增加或者刪除項目，我們說列表是可變的數(shù)據(jù)類型，即這種類型是可以被改變的，且列表是可以嵌套的。
2、元祖(tuple)
元祖和列表十分相似，不過元祖是不可變的。即你不能修改元祖。
元祖通過圓括號中用逗號分隔的項目定義。元祖通常在使語句或者用戶定義的函數(shù)能夠安全的采用一組值得時候，即被使用的元祖的值不會改變。元祖可以嵌套。
3、字典(Dictionary)
字典類似于你通過聯(lián)系人名稱查找地址和聯(lián)系人詳細(xì)情況的地址簿，即我們把鍵（名字）和值（詳細(xì)情況）聯(lián)系在一起。注意，鍵必須是唯一的，就像如果有兩個人恰巧同名的話，你無法找到正確信息。
鍵值對在字典中以這樣的方式標(biāo)記：d={key:value,key2:value2}.注意他們的鍵/值對用冒號分割，而各個隊用逗號分隔，所有這些都包括在花括號中。另外，記住字典中的鍵/值是沒有順序的。如果你想要一個特定的順序，那么你應(yīng)該在使用前對他們排序。
明顯答案： 不一樣
相同點(diǎn)：都不可改變。都可以進(jìn)行切片。
不同點(diǎn)：字符串有很多方法
元祖可以包含字符串
類型不同。字符串是文本型，元祖是序列。
↑↑↑點(diǎn)擊上方藍(lán)字，回復(fù)資料，10個G的驚喜
作者：陳tooyoung@阿里云Python訓(xùn)練營 博客地址：
Python 是一種通用編程語言，其在科學(xué)計算和機(jī)器學(xué)習(xí)領(lǐng)域具有廣泛的應(yīng)用。如果我們打算利用 Python 來執(zhí)行機(jī)器學(xué)習(xí)，那么對 Python 有一些基本的了解就是至關(guān)重要的。本 Python 入門系列體驗就是為這樣的初學(xué)者精心準(zhǔn)備的。
列表的定義
列表的創(chuàng)建
向列表中添加元素
刪除列表中的元素
獲取列表中的元素
列表的常用操作符
列表的其他方法
元組
創(chuàng)建和訪問一個元組
更新和刪除一個元組
元組相關(guān)的操作符
內(nèi)置方法
解壓元組
列表
簡單數(shù)據(jù)類型
整型
浮點(diǎn)型
布爾型
容器數(shù)據(jù)類型
列表
元組
字典
集合
字符串
列表的定義
列表是有序集合，沒有固定大小，能夠保存任意數(shù)量任意類型的 Python 對象，語法為[元素1, 元素2, ..., 元素n]。
關(guān)鍵點(diǎn)是「中括號 []」和「逗號 ,」
中括號 把所有元素綁在一起
逗號 將每個元素一一分開
列表的創(chuàng)建 創(chuàng)建一個普通列表x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(x, type(x))
# ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
x = [2, 3, 4, 5, 6, 7]
print(x, type(x))
# [2, 3, 4, 5, 6, 7]
利用range()創(chuàng)建列表x = list(range(10))
print(x, type(x))
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
x = list(range(1, 11, 2))
print(x, type(x))
# [1, 3, 5, 7, 9]
x = list(range(10, 1, -2))
print(x, type(x))
# [10, 8, 6, 4, 2]
利用推導(dǎo)式創(chuàng)建列表x = [0] * 5
print(x, type(x))
# [0, 0, 0, 0, 0]
x = [0 for i in range(5)]
print(x, type(x))
# [0, 0, 0, 0, 0]
x = [i for i in range(10)]
print(x, type(x))
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
x = [i for i in range(1, 10, 2)]
print(x, type(x))
# [1, 3, 5, 7, 9]
x = [i for i in range(10, 1, -2)]
print(x, type(x))
# [10, 8, 6, 4, 2]
x = [i ** 2 for i in range(1, 10)]
print(x, type(x))
# [1, 4, 9, 16, 25, 36, 49, 64, 81]
x = [i for i in range(100) if (i % 2) != 0 and (i % 3) == 0]
print(x, type(x))
# [3, 9, 15, 21, 27, 33, 39,
注意：
由于list的元素可以是任何對象，因此列表中所保存的是對象的指針。即使保存一個簡單的[1,2,3]，也有3個指針和3個整數(shù)對象。
x = [a] * 4操作中，只是創(chuàng)建4個指向list的引用，所以一旦a改變，x中4個a也會隨之改變。
x = [[0] * 3] * 4
print(x, type(x))
# [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]]
x[0][0] = 1
print(x, type(x))
# [[1, 0, 0], [1, 0, 0], [1, 0, 0], [1, 0, 0]]
a = [0] * 3
x = [a] * 4
print(x, type(x))
# [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]]
x[0][0] = 1
print(x, type(x))
# [[1, 0, 0], [1, 0, 0], [1, 0, 0], [1, 0, 0]]
創(chuàng)建一個混合列表mix = [1, 'lsgo', 3.14, [1, 2, 3]]
print(mix, type(mix))
# [1, 'lsgo', 3.14, [1, 2, 3]]
創(chuàng)建一個空列表empty = []
print(empty, type(empty)) # []
列表不像元組，列表內(nèi)容可更改 (mutable)，因此附加 (append,extend)、插入 (insert)、刪除 (remove,pop) 這些操作都可以用在它身上。
向列表中添加元素
list.append(obj)在列表末尾添加新的對象，只接受一個參數(shù)，參數(shù)可以是任何數(shù)據(jù)類型，被追加的元素在 list 中保持著原結(jié)構(gòu)類型。
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
x.append('Thursday')
print(x)
# ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Thursday']
print(len(x)) # 6
此元素如果是一個 list，那么這個 list 將作為一個整體進(jìn)行追加，注意append()和extend()的區(qū)別。
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
x.append(['Thursday', 'Sunday'])
print(x)
# ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', ['Thursday', 'Sunday']]
print(len(x)) # 6
list.extend(seq)在列表末尾一次性追加另一個序列中的多個值（用新列表擴(kuò)展原來的列表）
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
x.extend(['Thursday', 'Sunday'])
print(x)
# ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Thursday', 'Sunday']
print(len(x)) # 7
嚴(yán)格來說append是追加，把一個東西整體添加在列表后，而extend是擴(kuò)展，把一個東西里的所有元素添加在列表后。
list.insert(index, obj)在編號index位置插入obj。
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
x.insert(2, 'Sunday')
print(x)
# ['Monday', 'Tuesday', 'Sunday', 'Wednesday', 'Thursday', 'Friday']
print(len(x)) # 6
刪除列表中的元素
list.remove(obj)移除列表中某個值的第一個匹配項
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
x.remove('Monday')
print(x) # ['Tuesday', 'Wednesday', 'Thursday', 'Friday']
list.pop([index=-1])移除列表中的一個元素（默認(rèn)最后一個元素），并且返回該元素的值
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
y = x.pop()
print(y) # Friday
y = x.pop(0)
print(y) # Monday
y = x.pop(-2)
print(y) # Wednesday
print(x) # ['Tuesday', 'Thursday']
remove和pop都可以刪除元素，前者是指定具體要刪除的元素，后者是指定一個索引。
del var1[, var2 ……]刪除單個或多個對象。
如果知道要刪除的元素在列表中的位置，可使用del語句。
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
del x[0:2]
print(x) # ['Wednesday', 'Thursday', 'Friday']
獲取列表中的元素
通過元素的索引值，從列表獲取單個元素，注意，列表索引值是從0開始的。
通過將索引指定為-1，可讓Python返回最后一個列表元素，索引 -2 返回倒數(shù)第二個列表元素，以此類推。
x = ['Monday', 'Tuesday', 'Wednesday', ['Thursday', 'Friday']]
print(x[0], type(x[0])) # Monday
print(x[-1], type(x[-1])) # ['Thursday', 'Friday']
print(x[-2], type(x[-2])) # Wednesday
切片的通用寫法是start : stop : step
"start :"
以step為 1 (默認(rèn)) 從編號start往列表尾部切片。
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(x[3:]) # ['Thursday', 'Friday']
print(x[-3:]) # ['Wednesday', 'Thursday', 'Friday']
": stop"
以step為 1 (默認(rèn)) 從列表頭部往編號stop切片。
week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(week[:3]) # ['Monday', 'Tuesday', 'Wednesday']
print(week[:-3]) # ['Monday', 'Tuesday']
"start : stop"
以step為 1 (默認(rèn)) 從編號start往編號stop切片。
week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(week[1:3]) # ['Tuesday', 'Wednesday']
print(week[-3:-1]) # ['Wednesday', 'Thursday']
- "start : stop : step"
以具體的step從編號start往編號stop切片。注意最后把step設(shè)為 -1，相當(dāng)于將列表反向排列。
week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(week[1:4:2]) # ['Tuesday', 'Thursday']
print(week[:4:2]) # ['Monday', 'Wednesday']
print(week[1::2]) # ['Tuesday', 'Thursday']
print(week[::-1])
# ['Friday', 'Thursday', 'Wednesday', 'Tuesday', 'Monday']
" : "
復(fù)制列表中的所有元素（淺拷貝）。
week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(week[:])
# ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
淺拷貝與深拷貝list1 = [123, 456, 789, 213]
list2 = list1
list3 = list1[:]
print(list2) # [123, 456, 789, 213]
print(list3) # [123, 456, 789, 213]
list1.sort()
print(list2) # [123, 213, 456, 789]
print(list3) # [123, 456, 789, 213]
list1 = [[123, 456], [789, 213]]
list2 = list1
list3 = list1[:]
print(list2) # [[123, 456], [789, 213]]
print(list3) # [[123, 456], [789, 213]]
list1[0][0] = 111
print(list2) # [[111, 456], [789, 213]]
print(list3) # [[111, 456], [789, 213]]
列表的常用操作符
等號操作符：==
連接操作符+
重復(fù)操作符*
成員關(guān)系操作符in、not in
「等號 ==」，只有成員、成員位置都相同時才返回True。
列表拼接有兩種方式，用「加號 +」和「乘號 *」，前者首尾拼接，后者復(fù)制拼接。
list1 = [123, 456]
list2 = [456, 123]
list3 = [123, 456]
print(list1 == list2) # False
print(list1 == list3) # True
list4 = list1 + list2 # extend()
print(list4) # [123, 456, 456, 123]
list5 = list3 * 3
print(list5) # [123, 456, 123, 456, 123, 456]
list3 *= 3
print(list3) # [123, 456, 123, 456, 123, 456]
print(123 in list3) # True
print(456 not in list3) # False
前面三種方法（append,extend,insert）可對列表增加元素，它們沒有返回值，是直接修改了原數(shù)據(jù)對象。 而將兩個list相加，需要創(chuàng)建新的 list 對象，從而需要消耗額外的內(nèi)存，特別是當(dāng) list 較大時，盡量不要使用 “+” 來添加list。
列表的其它方法
list.count(obj)統(tǒng)計某個元素在列表中出現(xiàn)的次數(shù)
list1 = [123, 456] * 3
print(list1) # [123, 456, 123, 456, 123, 456]
num = list1.count(123)
print(num) # 3
list.index(x[, start[, end]])從列表中找出某個值第一個匹配項的索引位置
list1 = [123, 456] * 5
print(list1.index(123)) # 0
print(list1.index(123, 1)) # 2
print(list1.index(123, 3, 7)) # 4
list.reverse()反向列表中元素
x = [123, 456, 789]
x.reverse()
print(x) # [789, 456, 123]
list.sort(key=None, reverse=False)對原列表進(jìn)行排序。
key-- 主要是用來進(jìn)行比較的元素，只有一個參數(shù)，具體的函數(shù)的參數(shù)就是取自于可迭代對象中，指定可迭代對象中的一個元素來進(jìn)行排序。
reverse-- 排序規(guī)則，reverse = True降序，reverse = False升序（默認(rèn)）。
該方法沒有返回值，但是會對列表的對象進(jìn)行排序。
x = [123, 456, 789, 213]
x.sort()
print(x)
# [123, 213, 456, 789]
x.sort(reverse=True)
print(x)
# [789, 456, 213, 123]
# 獲取列表的第二個元素
def takeSecond(elem):
return elem[1]
x = [(2, 2), (3, 4), (4, 1), (1, 3)]
x.sort(key=takeSecond)
print(x)
# [(4, 1), (2, 2), (1, 3), (3, 4)]
x.sort(key=lambda a: a[0])
print(x)
# [(1, 3), (2, 2), (3, 4), (4, 1)]
元組
「元組」定義語法為：(元素1, 元素2, ..., 元素n)
小括號把所有元素綁在一起
逗號將每個元素一一分開
創(chuàng)建和訪問一個元組
Python 的元組與列表類似，不同之處在于tuple被創(chuàng)建后就不能對其進(jìn)行修改，類似字符串。
元組使用小括號，列表使用方括號。
元組與列表類似，也用整數(shù)來對它進(jìn)行索引 (indexing) 和切片 (slicing)。
t1 = (1, 10.31, 'python')
t2 = 1, 10.31, 'python'
print(t1, type(t1))
# (1, 10.31, 'python')
print(t2, type(t2))
# (1, 10.31, 'python')
tuple1 = (1, 2, 3, 4, 5, 6, 7, 8)
print(tuple1[1]) # 2
print(tuple1[5:]) # (6, 7, 8)
print(tuple1[:5]) # (1, 2, 3, 4, 5)
tuple2 = tuple1[:]
print(tuple2) # (1, 2, 3, 4, 5, 6, 7, 8)
創(chuàng)建元組可以用小括號 ()，也可以什么都不用，為了可讀性，建議還是用 ()。
元組中只包含一個元素時，需要在元素后面添加逗號，否則括號會被當(dāng)作運(yùn)算符使用。
x = (1)
print(type(x)) #
x = 2, 3, 4, 5
print(type(x)) #
x = []
print(type(x)) #
x = ()
print(type(x)) #
x = (1,)
print(type(x)) #
print(8 * (8)) # 64
print(8 * (8,)) # (8, 8, 8, 8, 8, 8, 8, 8)
創(chuàng)建二維元組。
x = (1, 10.31, 'python'), ('data', 11)
print(x)
# ((1, 10.31, 'python'), ('data', 11))
print(x[0])
# (1, 10.31, 'python')
print(x[0][0], x[0][1], x[0][2])
# 1 10.31 python
print(x[0][0:2])
# (1, 10.31)
更新和刪除一個元組week = ('Monday', 'Tuesday', 'Thursday', 'Friday')
week = week[:2] + ('Wednesday',) + week[2:]
print(week) # ('Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday')
元組有不可更改 (immutable) 的性質(zhì)，因此不能直接給元組的元素賦值，但是只要元組中的元素可更改 (mutable)，那么我們可以直接更改其元素，注意這跟賦值其元素不同。
t1 = (1, 2, 3, [4, 5, 6])
print(t1) # (1, 2, 3, [4, 5, 6])
t1[3][0] = 9
print(t1) # (1, 2, 3, [9, 5, 6])
元組相關(guān)的操作符
等號操作符：==
連接操作符+
重復(fù)操作符*
成員關(guān)系操作符in、not in
「等號 ==」，只有成員、成員位置都相同時才返回True。
元組拼接有兩種方式，用「加號 +」和「乘號 *」，前者首尾拼接，后者復(fù)制拼接。
t1 = (123, 456)
t2 = (456, 123)
t3 = (123, 456)
print(t1 == t2) # False
print(t1 == t3) # True
t4 = t1 + t2
print(t4) # (123, 456, 456, 123)
t5 = t3 * 3
print(t5) # (123, 456, 123, 456, 123, 456)
t3 *= 3
print(t3) # (123, 456, 123, 456, 123, 456)
print(123 in t3) # True
print(456 not in t3) # False
內(nèi)置方法
元組大小和內(nèi)容都不可更改，因此只有count和index兩種方法。
t = (1, 10.31, 'python')
print(t.count('python')) # 1
print(t.index(10.31)) # 1
count('python')是記錄在元組t中該元素出現(xiàn)幾次，顯然是 1 次
index(10.31)是找到該元素在元組t的索引，顯然是 1
解壓元組
解壓（unpack）一維元組（有幾個元素左邊括號定義幾個變量）
t = (1, 10.31, 'python')
(a, b, c) = t
print(a, b, c)
# 1 10.31 python
解壓二維元組（按照元組里的元組結(jié)構(gòu)來定義變量）
t = (1, 10.31, ('OK', 'python'))
(a, b, (c, d)) = t
print(a, b, c, d)
# 1 10.31 OK python
如果你只想要元組其中幾個元素，用通配符「*」，英文叫 wildcard，在計算機(jī)語言中代表一個或多個元素。下例就是把多個元素丟給了rest變量。
t = 1, 2, 3, 4, 5
a, b, *rest, c = t
print(a, b, c) # 1 2 5
print(rest) # [3, 4]
如果你根本不在乎 rest 變量，那么就用通配符「*」加上下劃線「_」。
t = 1, 2, 3, 4, 5
a, b, *_ = t
print(a, b) # 1 2
yield好了。調(diào)用的時候再轉(zhuǎn)化為元祖或者列表。很多情況下，甚至不需要轉(zhuǎn)化。
