1. 列表

??列表是 Python 最常用的數據類型，它是有序元素的集合，元素之間以逗號分隔，用中括號括起來，可以是任何數據類型。同時它也是一種序列，支持索引、切片、加、乘和成員檢查等。

• 數組：數據類型必須一致，有序的元素序列。
• 列表：Python 中沒有數組的概念，列表是一種特殊的數組，不要求數據類型一致，在內存中存儲方式類似於鏈表。

索引：即序列中元素的位置，從 0 開始

1.1 基本操作

??1. 創建列表

>>> L = []      # 創建一個空列表
>>> L = [3, '2', 6]

??2. 獲取元素

??獲取元素有三種方法，分別是：

• 通過索引獲取
• 列表切片獲取（獲得列表）
• for 循環

>>> L = [3, '2', 6]
>>> L[1]          # 索引       
'2'                      
>>> L[0:2]        # 切片
[3, '2']                 
>>> for i in L:     # for 循環     
...     print(i)         
...                      
3                        
2                        
6                        
 

??3. 刪除元素

??del 語句可以刪除整個列表，也可以用來刪除某個元素：

>>> L = [3, '2', 6]
>>> del L[1]    # 刪除索引為 1 的元素
>>> L
[3, 6]
>>> del L[0:1]      # 切片刪除
>>> L
[6]
>>> del L       # 刪除整個列表

??4. 修改列表

??列表修改，可以通過索引賦值修改，也可以通過切片修改：

>>> l = [3, '2', 6]                                                 
>>> l[1] = 4            # 通過索引賦值操作            
>>> l                               
[3, 4, 6]                           
>>> l[0:2] = [4, 5]       # 切片修改              
>>> l                               
[4, 5, 6]                           
 

??5. 成員運算

??列表支持 in、not in 成員運算，返回布爾值：

>>> l = [10, 22, 33, 66]
>>> 10 in l
True
>>> 22 not in l
False

??6. 獲取列表中列表中的元素

??列表支持多級索引：

>>> l = [10, 22, [33, 44], 66]
>>> l[2][1]
44

??7. 類型轉換

??通過 list（）函數可以將其他數據類型轉換為列表，需要註意的是 數字不能轉換為列表，因為數字不是可叠代對象。

>>> list('123')
['1', '2', '3']
>>> list({'name':'rose', 'age':18})
['name', 'age']

??列表轉換為字符串：

>>> l = ['abc', '123']      # 列表中只有字符串時，使用 .join（）方法
>>> ''.join(l)
'abc123'

>>> l = ['abc', 123]    # 當列表中有數字時              
>>> s = ''              
>>> for i in l:         
...     s += str(i)     
...                     
>>> print(s)            
abc123                  

??8. 切片（slice）

??列表是有序元素的集合，支持切片操作，slice（start，stop[，step]）有三個參數，開始結束位置以及步長。切片是對原列表的淺拷貝，不改變原列表。

>>> l = [10, 22, 33, 66]
>>> l[0:2]      # 包含開始位置，不包含結束位置
[10, 22]
>>> l[:3]       # 省略開始位置
[10, 22, 33]
>>> l[2:]       # 省略結束位置
[33, 66]
>>> l[:]        # 對原列表拷貝（副本）
[10, 22, 33, 66]
>>> l[:3:2]     # 步長為 2
[10, 33]
>>> l[::2]      # 對原列表拷貝，步長為 2
[10, 33]
>>> l[::-1]     # 反轉列表
[66, 33, 22, 10]

1.2 列表內置方法

# append（obj）：在列表最後添加一個元素
>>> l = [2, 3]
>>> l.append(6)
>>> l
[2, 3, 6]

# clear（）：清空列表中所有元素
>>> l = [2, 3]
>>> l.clear()
>>> l
[]

# copy（）：淺拷貝
>>> l = [2, 3]
>>> l1 = l.copy()
>>> l1
[2, 3]

# count（value）：統計列表中某個元素的個數
>>> l = ['a', 'b', 'c', 'a']
>>> l.count('a')
2

# extend（iterable）：往列表最後添加多給元素，參數必須是可叠代對象
>>> l = ['a', 'b', 'c', 'a']
>>> l.extend('12')
>>> l.extend([3, 5])
>>> l
['a', 'b', 'c', 'a', '1', '2', 3, 5]

# index（value，start=None，end=None）：查找某個元素的位置，可指定範圍，當有多個時，僅返回第一個的位置
>>> l = ['a', 'b', 'c', 'a', '1', '2', 3, 5]        # 若不存在報 ValueError
>>> l.index('a')
0

# insert（index，value）：往列表中任意位置插入一個元素，第一個為插入位置，第二個為插入元素
>>> l = ['a', 'b']
>>> l.insert(1, 2)
>>> l
['a', 2, 'b']

# pop（index=None）：刪除一個元素，並獲得它，默認是最後一個，可以指定索引
>>> l = ['a', 'b', 'c']
>>> res = l.pop()
>>> res
'c'
>>> l
['a', 'b']
>>> l.pop(1)
'b'
>>> l
['a']

# remove（value）：刪除一個元素，當有多個時，僅刪除第一個
>>> l = ['a', 'b', 'c', 'a']
>>> l.remove('a')
>>> l
['b', 'c', 'a']

# reverse（）：列表反轉
>>> l = ['a', 'b', 'c', 'a']
>>> l.reverse()
>>> l
['a', 'c', 'b', 'a']

# sort（func，key=None，reverse=True）：對列表中的元素進行排序，func 為排序算法（默認從小到大），key 為關鍵字，reverse=False 表示不顛倒順序，True 表示從大到小
>>> l = [22, 11, 33, 10]
>>> l.sort()
>>> l
[10, 11, 22, 33]
>>> l.sort(reverse=True)
>>> l
[33, 22, 11, 10]

2. 元組

??元組是一種特殊的列表，也是一種有序元素的集合，與列表的區別：

• 列表：可以修改、增加、刪除，使用中括號括起來
• 元組：一旦創建不可修改、增加、刪除，使用小括號括起來

2.1 基本操作

??1. 創建

??一般在創建元組時，推薦在最後一個元素加一個逗號【，】

>>> temp = ()
>>> temp = (3,)
>>> temp = (2, 3, 'ab',)

??2. 獲取

??元組獲取元素與列表一樣，同樣地可以通過索引、切片以及 for 循環遍歷獲取。其他數據類型轉換為元組，使用 tuple（）函數，方法與 list（）一樣。

>>> temp = (2, 3, 'ab')
>>> temp[1]
3
>>> temp[0:2]
(2, 3)
>>> for i in temp:
...     print(i)
2
3
ab

??3. 更新

??元組一旦創建，其一級元素不可被修改，但是元組裏面的二級元素（如 元組中的列表中的元素）可以被修改。

>>> temp = (2, 3, ['a', 'b'], 4)
>>> temp[2][0] = 'c'
>>> temp
(2, 3, ['c', 'b'], 4)

??另外還可以類似於 str 一樣，使用連接符 + 對其進行間接修改。但是需要註意的是，使用連接符修改將會產生一個新的元組（即驗證了元組不可被修改）。

>>> temp = (2, 3, 4)
>>> id(temp)
47622040
>>> temp = temp[:2] + (5,) + temp[2:]   # 在索引為 2 的位置插入一個元素 5
>>> temp
(2, 3, 5, 4)
>>> id(temp)        # 前後元組名相同，但 id 不同，不是一個元組
39030600

??4. 刪除

??一般情況，元組不使用時，將會被 Python 的回收機制自動刪除，因此不用特意刪除。

>>> temp = (2, 3, 4)
>>> temp = temp[:1] + temp[2:]
>>> temp
(2, 4)

>>> del temp        # 刪除整個元組

2.2 內置函數

# len(obj)：獲取元組長度
>>> temp = (2, 3, 4)
>>> len(temp)
3

# max、min（obj）：獲取元組中元組最大、小值
>>> max(temp)
4
>>> min(temp)
2

# tuple（）：類型轉換
>>> tuple('123'
... )
('1', '2', '3')
>>> tuple({'name':'rose', 'age':18})
('name', 'age')

2.3 內置方法

# count（value）：統計某個元素個數
>>> temp = (2, 3, 4, 2)
>>> temp.count(2)
2

# index（value，start=None，end=None）：獲取某個元素位置，若不存在，報 ValueError
>>> temp.index(2, 0, 3)
0

2.4 元祖拆包

??元組拆包即將元組中的元素平行賦值給變量。

>>> x,y,z = (1,2,3)
>>> print(x,y,z)
1 2 3

>>> infos = [(1,2,3), (4,5,6)]
>>> for i in infos:
...     print('%s %s %s'%i)
...
1 2 3
4 5 6

3. 字典

??字典是一種可變容器模型，可以存儲任意類型對象。由無序的鍵（key）值（value）對組成，每對之間以逗號分割，最外層以花括號包裹。

• 鍵：任意不可變類型（int、str、tuple 等），必須是唯一的。
• 值：任意類型

3.1 基本操作

??1. 創建

>>> d1 = {}
>>> d2 = {'name': 'rose', 'age': 18}
>>> d3 = dict()

??2. 訪問

??因為字典是無序的，所有只能通過 key 來訪問 value：

>>> d2 = {'name': 'rose', 'age': 18}
>>> d2['name']          # 這種方法，當 key 不存在是會報 KeyError
'rose'

>>> d2.get('age')
18

3. 刪除

??del 語句可以用來刪除一個元素，也可用於刪除整個字典：

>>> d2 = {'name': 'rose', 'age': 18}
>>> del d2['name']      # 刪除 name
>>> d2
{'age': 18}
>>> del d2      # 刪除整個字典

4. 修改

??通過 key 訪問到 value，對其進行賦值，便可完成修改：

>>> d2 = {'name': 'rose', 'age': 18}
>>> d2['name'] = 'tom'
>>> d2
{'name': 'tom', 'age': 18}

3.2 內置方法

??PART 1

# fromkeys（sequence[, value]）：內置的類方法 @staticmethod，接收一個序列，將序列中的元素作為鍵，value 默認為 None，返回一個新的字典
>>> d = dict.fromkeys(['a', 'b'], 2)
>>> d
{'a': 2, 'b': 2}

# get（key[, value]）：根據 key 獲取 value，即使 key 不存在也不會報錯，若 key 存在可以指定返回值
>>> d2 = {'name': 'rose', 'age': 18}
>>> d2.get('age')
18
>>> d2.get('gender', '沒找到')
'沒找到'

# pop（key[,default]）：根據 key 刪除一個元素，若 key 在字典中，將其刪除並返回。否則返回默認值，如果 key 不存在，且又未指定默認值，引發 KeyError
>>> d2 = {'name': 'rose', 'age': 18}          
>>> s = d2.pop('name')   
>>> s
'rose'                                        
             
>>> d2.pop('gender', "don't find")            
"don't find"                                  
>>> d2.pop('gender')                  # key 不存在，且又未指定默認值，引發 KeyError        
Traceback (most recent call last):            
  File "<stdin>", line 1, in <module>         
KeyError: 'gender'                         
    
# popitem（）：從字典中隨意刪除一個元素，並返回
>>> d2 = {'name': 'rose', 'age': 18}
>>> s = d2.popitem()
>>> s
('age', 18)
>>> d2
{'name': 'rose'}

# setdefault（key[,default]）：設置字典鍵值對，若存在，不設置，並獲取當前 key 對應的 value。若不存在，設置
>>> d2 = {'name': 'rose', 'age': 18}
>>> d2.setdefault('gender', 'male')
'male'
>>> d2.setdefault('age', 19)
18
>>> d2
{'name': 'rose', 'age': 18, 'gender': 'male'}

# update（**kwargs）：更新字典
>>> d2 = {'name': 'rose', 'age': 18}
>>> d2.update(age=20, gender='male')    # 若 key 存在，在更新，若不存在則新建鍵值對
>>> d2
{'name': 'rose', 'age': 20, 'gender': 'male'}

>>> d2.update({'a':20})     # 傳入一個字典
>>> d2
{'name': 'rose', 'age': 18, 'a': 20}

??PART 2

# keys（）：返回字典的 key
>>> d2 = {'name': 'rose', 'age': 18}
>>> k = d2.keys()
>>> k
dict_keys(['name', 'age'])
>>> for i in k:
...     print(i)
...
name
age

# values（）： 返回字典的 value
>>> v = d2.values()
>>> v
dict_values(['rose', 18])
>>> for i in v:
...     print(i)
...
rose
18

# items（）：返回字典的 key、value
>>> for k, v in d2.items():
...     print(k, v)
...
name rose
age 18

# clear（）：清空整個字典裏的元組
>>> d2 = {'name': 'rose', 'age': 18}
>>> d2.clear()
>>> d2
{}

# copy（）：對字典進行淺拷貝
>>> d2 = {'name': 'rose', 'age': 18}
>>> d = d2.copy()
>>> d
{'name': 'rose', 'age': 18}

4. 集合

??由不同元素組成的無序集合，裏面的元素必須是不可變的，且每個元素都是唯一的。

• 無序，不能用索引方式訪問
• 只能是數字、字符串、元組等不可變數據

4.1 基本操作

??1. 創建

??創建一個集合有兩種方法：一是直接用大括號把一堆元素括起來；另一種是使用 set（）。

>>> s = {1, 2, 3}       # 不能使用大括號直接創建一個空集合，那樣會創建一個字典
>>> s = set('123')
>>> s
{'3', '1', '2'}

>>> s = {1, 2, 3, 2}    # 創建一個重復的集合，會自動將重復的元素過濾
>>> s
{1, 2, 3}

??2. 訪問

??因為集合中元素是無序的，所以不能通過索引訪問，只能用 for 循環每個元素，或成員運算符判斷元素是否在集合中。

>>> s = {'3', '1', '2'}
>>> for i in s:
...     print(i)
...
3
1
2
>>> '3' in s
True

??3. 轉換類型

??不能將數字和字典轉換為集合。

>>> set([1,2,3])        
{1, 2, 3}
>>> set('123')
{'3', '1', '2'}

4.2 內置方法

# add（*args， **kwargs）：添加一個元素
>>> s = {1, 2, 3}
>>> s.add(4)
>>> s
{1, 2, 3, 4}

# clear（）：清空集合
>>> s = {1, 2, 3}
>>> s.clear()
>>> s
set()

# copy（）：淺拷貝
>>> s = {1, 2, 3}
>>> s1 = s.copy()
>>> s1
{1, 2, 3, 4}

# pop（）：隨機移除一個元素
>>> s1 = {1, 2, 3}
>>> s1.pop()
1
>>> s1
{2, 3}

# remove（value）：刪除某個指定元素，若元素不存在拋出 KeyError
>>> s1 = {1, 2, 3}
>>> s1.remove(2)
>>> s1
{1, 3}

# discard（value）：與 remove（）一樣都是刪除某個元素，但是元素不存在不會報錯
>>> s1 = {1, 2, 3}
>>> s1.discard(4)

# difference_update（set2）：更新集合，相當於 s1 = s1 - s2
>>> s1 = {1, 2, 3}
>>> s2 = {2, 3, 4}
>>> s1.difference_update(s2)
>>> s1
{1}

# intersection_update（set2）：求交集，與 intersection（）不同的是它不會改變原集合，而 intersection（）返回新的集合
>>> s1 = {1, 2, 3}                   
>>> s2 = {2, 3, 4}                   
>>> s1.intersection(s2)              
{2, 3}                               
>>> s1                               
{1, 2, 3}                            

# set1.isdisjoint（set2）：判斷兩個集合有無交集，有交集返回 False
>>> s1 = {1, 2, 3}
>>> s2 = {2, 3, 4}
>>> s1.isdisjoint(s2)
False

# s1.issubset（set2）：判斷 set1 是否是 set2 的子集（即 set1 <= set2)
# set1.issuperset（set2）：判斷 set1 是否是 set2 的父集
>>> s1 = {1, 2, 3}
>>> s2 = {2, 3, 4}
>>> s1.issubset(s2)
False
>>> s1.issuperset(s2)
False

# set.update（set2）：給集合添加元素，參數可以是集合、字符串、列表、元組、字典等
>>> s1 = {1, 2, 3}                               
>>> s1.update({'a':'b'})           # 字典              
>>> s1                                           
{1, 2, 3, 'a'}                                                    
>>> s1.update([4, 5])                  # 列表          
>>> s1.update({6, 7})                        # 集合    
>>> s1                                           
{1, 2, 3, 4, 5, 6, 7, 'a'}                       

# set1.symmetric_difference_update（set2）：求交叉補集，在原集合上更新，將不重復的元素添加到原集合中
>>> s1 = {1, 2, 3}
>>> s2 = {2, 3, 4}
>>> s1.symmetric_difference_update(s2)
>>> s1
{1, 4}

??不可變集合

??有時想要像元組一樣不能隨意添加、刪除集合元素，可以使用 frozenset（）函數定義一個不可變集合。

>>> s1 = frozenset({1, 2, 3})
>>> s1.add(4)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'frozenset' object has no attribute 'add'

4.3 集合關系運算

??1. 交集（&）

??交集即兩個集合重復的部分，intersection（）方法可以用來求兩個集合的交集，並返回交集，不改變原集合。

set1.intersection（set2）
set1 & set2

>>> s1 = {1, 2, 3}
>>> s2 = {2, 3, 4}
>>> s1.intersection(s2)
{2, 3}
>>> s1
{1, 2, 3}
>>> s1 & s2
{2, 3}

??2. 並集（|）

??並集即將兩個集合的所有元素並在一起，重復的只出現一次，可以用作簡單去重。

set1.union(set2)
set1 | set2

>>> s1 = {1, 2, 3}
>>> s2 = {2, 3, 4}
>>> s1.union(s2)
{1, 2, 3, 4}
>>> s1 | s2
{1, 2, 3, 4}

??3. 差集（-）

??差集即 set1 - set2，兩個集合中重復的元素去掉，僅包含第一個集合中剩余的元素，不包含第二個集合剩余的元素，不改變原集合。

set1.difference(set2）
set1 - set2

>>> s1 = {1, 2, 3}
>>> s2 = {2, 3, 4}
>>> s1.difference(s2)
{1}
>>> s1 - s2
{1}
>>> s1
{1, 2, 3}

??4. 交叉補集（^）

??交叉補集即兩個集合不重復的元素，不改變原集合。

set1.symmetric_difference(set2)
set1 ^ set2

>>> s1 = {1, 2, 3}                                             
>>> s2 = {2, 3, 4}                                             
>>> s1.symmetric_difference(s2)                                
{1, 4}                                                         
>>> s1                                                         
{1, 2, 3}                                                      
>>> s1 ^ s2                                                    
{1, 4}                                                         

??5. 去重

??可以利用集合對列表進行簡單去重，先將其轉換為集合，再轉換為列表，需要註意的是，元素順序將會改變。

>>> names = ['rose', 'lila', 'tom', 'rose']
>>> names = list(set(names))
>>> names
['lila', 'tom', 'rose']

5. 序列

??序列即有序元素集合，是可叠代對象，包括字符串、列表、元組，它們之間用很多共同點：

• 都可以通過索引獲取值，即是有序（索引從 0 開始）
• 可以切片
• 有共同的操作符（重復、拼接、成員關系操作符等）

??enumerate（）方法

??enumerate（iterable）方法用於生成一個二元組（二元組即元素數量為二的元組）構成的一個可叠代對象，每個二元組由可叠代索引與對應元素組成。

>>> s = 'abc'
>>> for i in enumerate(s):
...     print(i)
...
(0, 'a')
(1, 'b')
(2, 'c')

6. 練習

??字典無限嵌套

cities={
    '北京':{
        '朝陽':['國貿','CBD','天階','我愛我家','鏈接地產'],
        '海澱':['圓明園','蘇州街','中關村','北京大學'],
        '昌平':['沙河','南口','小湯山',],
        '懷柔':['桃花','梅花','大山'],
        '密雲':['密雲A','密雲B','密雲C']
    },
    '河北':{
        '石家莊':['石家莊A','石家莊B','石家莊C','石家莊D','石家莊E'],
        '張家口':['張家口A','張家口B','張家口C'],
        '承德':['承德A','承德B','承德C','承德D']
    }
}
for i in cities['北京']:
    print(i)
朝陽
海澱
昌平
懷柔
密雲

for i in cities['北京']['海澱']:
    print(i)
圓明園
蘇州街
中關村
北京大學

基本數據類型（二）