Python中的內建資料結構（Built-in Data Structure）:列表list、元組tuple、字典dict、集合set，涵蓋的僅有部分重點。

一、列表list

---

 

list的顯著特徵：

1. 列表中的每個元素都可變的，意味著可以對每個元素進行修改和刪除；
2. 列表是有序的，每個元素的位置是確定的，可以用索引去訪問每個元素；
3. 列表中的元素可以是Python中的任何物件；
4. 可以為任意物件就意味著元素可以是字串、整數、元組、也可以是list等Python中的物件。

----資料操作：

1、直接建立列表

mylist = ['
 
Google', 'Yahoo', 'Baidu']

2、對列表中的指定位置變更資料

mylist = ['Google', 'Yahoo', 'Baidu']

#變更索引位置1Yahoo的內容為Microsoft
mylist[1] = 'Microsoft'


#執行結果： ['Google', 'Microsoft', 'Baidu']

3、在列表後面追加元素

mylist.append('Alibaba')  #執行結果： ['Google', 'Microsoft', 'Baidu', 'Alibaba']

4、在指定位置插入元素

mylist.insert(1, '
 
Tencent')  # ['Google', 'Tencent', 'Microsoft', 'Baidu', 'Alibaba']

5、刪除元素

mylist = ['Google', 'Tencent', 'Microsoft', 'Baidu', 'Alibaba']

# 刪除尾部元素
mylist.pop()      # 會返回被刪除元素
# 刪除指定位置的元素
mylist.pop(1)  # 刪除索引為1的元素，並返回刪除的元素

mylist.remove('Microsoft') #刪除列表中的Microsoft

del mylist[1:3]       #
 
刪除列表中索引位置1到位置 3 的資料

6、替換元素

mylist[0] = 'Baidu'
mylist[1] = ['python', 'java', 'php']  # 集合的資料型別可以不同，也可以是集合

7、列表排序

mylist = [1, 2, 5, 4]
mylist.sort()          # [1, 2 ,4, 5]

如果列表裡面是字母，則根據Ascii碼來排序

8、獲取列表長度

mylist = [1, 2, 5, 4]
len(mylist)

9、獲取列表指定位置的資料

mylist = ['Google', 'Tencent', 'Microsoft', 'Baidu', 'Alibaba','Sina']
#獲取索引位置1的資料
mylist[1]        #'Tencent'
#獲取索引位置1到5的資料，注意這裡只會取到索引位置4,這裡叫做取頭不取尾
mylist[1:5]   # 'Tencent', 'Microsoft', 'Baidu', 'Alibaba'
#獲取從最頭到索引位置5的資料
mylist[ :5]   #'Google', 'Tencent', 'Microsoft', 'Baidu', 'Alibaba'

#獲取從索引位置2開到最後的資料
mylist[2:]    #'Microsoft', 'Baidu', 'Alibaba','Sina'

10、用迴圈來建立列表

a = [1,2,3,4,5,6]
#在a的資料基礎上每個資料乘以10，再生成一個列表b，
b = [i*10 for i in a]
print(a)
print(b)

#執行結果如下:
#    [1, 2, 3, 4, 5, 6]
#    [10, 20, 30, 40, 50, 60]

11、過濾列表中的內容放入新的列表中

#生成一個從1到20的列表

a = [x for x in range(1,20)]

#把a中所有偶數生成一個新的列表b

b = [m for m in a if m % 2 == 0]

print(b)


#執行結果如下:
#        [2, 4, 6, 8, 10, 12, 14, 16, 18]

12、巢狀式生成列表

#生成一個列表a
a = [i for i in range(1,4)]
print(a)

#生成一個列表b
b = [i for i in range(100,400) if i % 100 == 0]
print(b)

# 巢狀式 
c = [m+n for m in a for n in b]
print(c)


#執行結果：
#    [1, 2, 3]
#    [100, 200, 300]
#    [101, 201, 301, 102, 202, 302, 103, 203, 303]

 

Python中包含6中內建的序列：列表，元組，字串、Unicode字串、buffer物件和xrange物件。

----list函式

>>> list("Hello world")
['H', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

可以通過list將序列建立為列表。

其實list為一種型別並非函式，但此處二者並無多大區別。下面的tuple、dict也是如此。

 

二、元組tuple

---

 

重點：元組Tuple，用法與List類似，但Tuple一經初始化，就不能修改，沒有List中的append(), insert(), pop()等修改的方法，只能對元素進行查詢

下面看個例子來證實一下我們說的：

>>> a = (1,2,3,4)
>>> a
(1, 2, 3, 4)
>>> print(type(a))
<class 'tuple'>
>>> a[1]=5
Traceback (most recent call last):
  File "<pyshell#3>", line 1, in <module>
    a[1]=5
TypeError: 'tuple' object does not support item assignment
>>> a[1:1] = 5
Traceback (most recent call last):
  File "<pyshell#4>", line 1, in <module>
    a[1:1] = 5
TypeError: 'tuple' object does not support item assignment
>>> a[1]
2

從上面的例子，證實了tuple不支援對元素的修改（包括刪除），tuple一初始化便固定下來了。

再來看一個例子：

>>> a = ('a','b',['A','B'])
>>> print(type(a))      #檢測a的資料型別是什麼
<class 'tuple'>        #檢測出a的型別是元組tuple
>>> print(a)
('a', 'b', ['A', 'B'])
>>> a[2][0] = 'X'    #嘗試變更資料，成功了，為什麼？
>>> a[2][1] = 'y'
>>> print(a)            #打印出變更後的內容
('a', 'b', ['X', 'y'])
>>> print(type(a[2]))    #檢測a的資料型別是什麼
<class 'list'>                #檢測出a[2]的型別是list

這裡看似元素中的元素改變了，可是仔細分析下，元組中的第三個元素是一個列表。

程式碼4,5行改變的是列表中的值，元組所指的這個元素列表並沒有改變，需要注意這點！

這就涉及到Python中的可變物件和不可變物件，像list這樣的就是可變物件，tuple便是不可變物件。

元組是固定的列表，那麼元組的意義何在呢？

因為tuple不可變，所以程式碼更安全。如果可能，能用tuple代替list就儘量用tuple並且需要注意元組中元素的可變性！！

空的tuple可以記為()，若只有一個元素的tuple記為(1,)

t = (1,)  # 如果需要是Tuple，就必須加上逗號，否則變成成了數字1了
# 這裡如果沒有“,”就變成了“(1)”

因為記為(1)的話，這個實際代表的是數字1，此時()是數學公式中的小括號

因為元組是固定的列表，所以其內建的大多數的方法和列表是差不多的。

可以通過tuple將序列轉換為元組，用法和list一樣

>>> tuple('Hello,world!')
('H', 'e', 'l', 'l', 'o', ',', 'w', 'o', 'r', 'l', 'd', '!')

 

三、字典dict（dictionary）

---

 

        字典dictionary全稱這個概念就是基於現實生活中的字典原型，生活中的使用名稱-內容對資料進行構建，Python中使用鍵(key)-值(value)儲存，也就是java、C++中的map。

 

dict的顯著特徵：

---

 

• 字典中的資料必須以鍵值對的形式出現，即k,v： 

　　　　　　key:必須是可雜湊的值，比如intmstring,float,tuple,但是，list,set,dict不行 

　　　　　　value:任何值

• 鍵不可重複，值可重複

　　　　　　鍵若重複字典中只會記該鍵對應的最後一個值

• 字典中鍵(key)是不可變的，何為不可變物件，不能進行修改；而值(value)是可以修改的，可以是任何物件。

　　　　　　在dict中是根據key來計算value的儲存位置，如果每次計算相同的key得出的結果不同，那dict內部就完全混亂了。

 

----字典生成建立方式 

#建立空字典1
    
d = {}
print(d)

#建立空字典2
d = dict()

#直接賦值方式

d = {"one":1,"two":2,"three":3,"four":4}


#常規字典生成式

dd = {k:v for k,v in d.items()}
print(dd)

#加限制條件的字典生成方式

ddd = {k:v for k,v in d.items() if v % 2 ==0}
print(ddd)

 

----字典的常見操作_____訪問、刪除、變更字典裡面的內容

#訪問字典中的資料
d = {"one":1,"two":2,"three":3,"four":4}
print(d["one"])
#變更字典裡面的資料
d["one"] = "eins"
print(d)

#刪除一個數據,使用del
del d["one"]
print(d)

#執行結果如下：
1
{'one': 'eins', 'two': 2, 'three': 3, 'four': 4}
{'two': 2, 'three': 3, 'four': 4}

----字典中成員檢測

d = {"one":1,"two":2,"three":3,"four":4}

if 2 in d:
    print("value")
    
if "two" in d:
    print("key")
    
if ("two",2) in d:
    print("kv")

----使用for迴圈訪問字典

d = {"one":1,"two":2,"three":3,"four":4}
#使用for迴圈，直接按key值訪問

for k in d:
    print(k,d[k])
    
#上述程式碼也可以寫成如下
    
for k in d.keys():
    print(k,d[k])

#只訪問字典的值

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

#以下是特殊用法

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

----字典相關函式

通用函式：len,max,min,dict

d = {"one":1,"two":2,"three":3,"four":4}
print(max(d))
print(min(d))
print(len(d))

dict() 函式的使用方法：

dict0 = dict()  # 傳一個空字典
print('dict0:', dict0)
 
dict1 = dict({'three': 3, 'four': 4})  # 傳一個字典
print('dict1:', dict1)
 
dict2 = dict(five=5, six=6)  # 傳關鍵字
print('dict2:', dict2)
 
dict3 = dict([('seven', 7), ('eight', 8)])  # 傳一個包含一個或多個元祖的列表
print('dict3:', dict3)
 
dict5 = dict(zip(['eleven', 'twelve'], [11, 12]))  # 傳一個zip()函式
print('dict5:', dict5)

str(字典)：返回字典的字串格式

d = {"one":1,"two":2,"three":3,"four":4}

print(str(d))

clear：清空字典

items：返回字典的鍵值對組成的元組格式

d = {"one":1,"two":2,"three":3,"four":4}

i = d.items()
print(type(i))
print(i)

d.clear()
print(d)

keys：返回字典的鍵組成的一個結構

d = {"one":1,"two":2,"three":3,"four":4}
k = d.keys()
print(type(k))
print(k)

values：返回字典的值組成的一個結構

d = {"one":1,"two":2,"three":3,"four":4}
v = d.values()
print(type(v))
print(v)

get：根據制定鍵返回相應的值，好處是可以設定預設值

d = {"one":1,"two":2,"three":3,"four":4}

print(d.get("one333"))

#get預設值是None,可以設定
print(d.get("one",100))
print(d.get("one222",100))

fromkeys：使用指定的序列作為鍵，使用一個值作為字典的所有的鍵的值

p = ["one","two","three","four",]
#注意fromkeys兩個引數的型別
#注意fromkeys的呼叫主體
d = dict.fromkeys(p,"222")
print(d)

 

四、集合set

---

 

• 集合更接近數學上集合的概念。集合中每個元素都是無序的、不重複的任意物件。
• 可以通過集合去判斷資料的從屬關係，也可以通過集合把資料結構中重複的元素減掉。集合可做集合運算，可新增和刪除元素。
• 集合內資料無序，即無法使用索引和分片
• 集合內部資料元素具有唯一性，可以用來排除重複資料
• 集合內的資料:str,int,float,tuple,冰凍集合等，即內部只能放置可雜湊資料

----集合的定義

#集合的定義,set()
s = set()
print(type(s))
print(s)

#也可以像下面這樣做,大括號內一定要有值，否則定義出的將是一個dict
s = {1,2,3,4,5,6,7}
print(s)

建立集合時需要用list作為輸入集合，可通過add()方法增加元素，remove()方法刪除元素

s = set([1,2,3])
s.add(6)
s.remove(2)

集合的內涵

普通集合內涵
--------以下集合會在初始化後自動過濾掉重複元素

s = {33,1,33,6,9,126,8,6,3,77,88,99,126}
print(s)

普通迴圈集合內涵

s = {33,1,33,6,9,126,8,6,3,77,88,99,126}
ss = {i for i in s}
print(ss)

帶條件的集合內涵

s = {33,1,33,6,9,126,8,6,3,77,88,99,126}
sss = {i for i in s if i % 2 ==0}
print(sss)

多迴圈集合的內涵

s1 = {1,2,3,4}
s2 = {"nice","to","meet","you"}

s = {m*n for m in s2 for n in s1}
print(s)

----集合函式

•  intersection：交集
• difference：差集
• union：並集
• issubset：檢查一個集合是否為另一個子集
• issuperset：檢查一個集合是否為另一個超集 

通過程式碼來看區別：

s1 = {1,2,3,4,5,6,7}
s2 = {5,6,7,8,9}

#交集
s_1 = s1.intersection(s2)
print("交集:",s_1)

#差集
s_2 = s1.difference(s2)
print("差集:",s_2)

#並集
s_3 = s1.union(s2)
print("並集:",s_3)

#檢查一個集合是否為另一個子集
s_4 = s1.issubset(s2)
print("檢查子集結果：",s_4)

#檢查一個集合是否為另一個超集
s_5 = s1.issuperset(s2)
print("檢查超集結果：",s_5)

這裡是執行結果：
交集: {5, 6, 7}
差集: {1, 2, 3, 4}
並集: {1, 2, 3, 4, 5, 6, 7, 8, 9}
檢查子集結果： False
檢查超集結果： False

frozen set:冰凍集合

• 冰凍集合是不可以進行任何修改的集合
• frozenset是一種特殊集合

建立冰凍集合的方式：

s = frozenset()

  

每天進步一點點，不要停止前進的腳步