一、容器

Python中的容器就是之前提到的複雜數據類型，用來存放大量數據的容器，是Python語言裏面的比較重要數據類型，本質是對象，Python底層基於雙向鏈表的實現。而且Python中有許多有關於容器的方法。個人覺得，Python設計者對容器有一種莫名的熱愛。真的！方法超級多。

共有四種，分別是列表（list）、集合（set），元組（tuple），字典（dict）

可以輸入通過使用dir()方法，展示關於序列所有的方法，還可以通過len()方法，判斷一個序列有多少個元素，還可以通過del關鍵字，刪除序列對象或者元素。

代碼

list_1 = [True, "shuzi", 4.2, [1, 2], 5]
print(dir(list_1), end = "\n\n")

print("這個列表有%d個元素！"% len(list_1))
del list_1[1]
print(list_1)
del list_1

顯示結果

二、序列

序列是基類類型，他的擴展類型分別是：字符串、元組和列表。就可以理解爲序列是字符串、元組和列表的祖先一樣。

序列在這裏只是瞭解一下，不做過多的講解！

三、列表（list）

列表是一種線性表，由大量的元素組成，每一個元素都可以存儲數據，可以隨意更改其中的數據，而且列表裏面的元素可以是任意的數據類型，無長度限制。列表的索引值是從0開始的，也就是說排隊時第一個人時從0開始讀取的。

1、創建

列表的創建有兩種方法元素間用逗號,分隔，分別是：方括號 [] 、list() 創建

列表名 = [元素1, 元素2, 元素3, …]
列表名 = list((元素1, 元素2, 元素3, …))

代碼

list_1 = [True, "shuzi", 4.2, [1, 2], 5]	#利用弱數據類型語言的特點創建一個帶元素列表
list_2 = list()	#創建一個空列表
list_3 = list((5, 76, 47, 3, 4,))	#創建一個帶元素的列表
print(list_1)	
print(type(list_1))
print(list_2)
print(type(list_2))
print(list_3)
print(type(list_3))

顯示結果

注意：儘量不要用list作爲變量名，因爲當list變成變量名的時候，list()方法將不能使用

2、訪問列表中的元素

想要訪問列表中的元素一般通過下標訪問，在編程中，99%技術或者語言，下標都是從0開始的（不要問爲什麼，這就是規定）。

列表名[下標]

代碼

list_1 = [True, "shuzi", 4.2, [1, 2], 5]
print(list_1[2])

顯示結果

3、賦值

列表名[下標] = 新值

代碼

list_1 = [True, "shuzi", 4.2, [1, 2], 5]
print(list_1[2])
list_1[2] = 90
print(list_1[2])

顯示結果

注意：下標不要越界，會報錯

4、方法

由於列表的方法比較多，就不一一講解了，主要講解以下常用的幾個方法： ['append', 'clear','copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

a、append方法

append方法是能夠在列表末尾添加一個新的元素，所以括號裏面必須有一個值。

代碼

list_1 = [True, "shuzi", 4.2, [1, 2], 5]
list_1.append(4)
print(list_1)

顯示結果

b、clear方法

clear方法是清除列表中的所有元素，這裏說的是清除，不是刪除列表這個對象。

代碼

list_1 = [True, "shuzi", 4.2, [1, 2], 5]
list_1.clear()
print(list_1)

顯示結果

c、copy方法

copy方法是複製整個列表給另一個列表裏，而列表間的賦值不同，賦值是一個列表有兩個名字，有點像Linux裏面的軟鏈接，copy方法是一個名字一個單獨不相干的列表。

代碼

list_1 = [True, "shuzi", 4.2, [1, 2], 5]
list_2 = [4,5,7,]
list_3 = [4,54,79,]
print(list_1)
print(list_2)
print(list_3)
list_2 = list_1.copy()
list_3 = list_1
print(list_1)
print(list_2)
print(list_3)
list_2[3] = 10000
list_3[3] = "xax"
print(list_1)
print(list_2)
print(list_3)

顯示結果

d、count方法

count方法是統計元素在列表中的個數。

代碼

list_1 = [True, "shuzi", 4.2, [1, 2], 5]
print(list_1.count(5))

顯示結果

e、index方法

index方法是查詢元素在列表中第一次出現的下標位置，如果列表中不存在該元素，則拋出異常。

代碼

list_1 = [True, "shuzi", 4.2, [1, 2], 5, 50, 5]
print(list_1.index(5))
print(list_1.index(7))

顯示結果

f、extend方法

extend方法是將兩個列表合併，如果沒有列表或者不是列表類型在括號中，則拋出異常。

代碼

list_1 = [True, "shuzi", 4.2, [1, 2], 5, 50, 5]
list_1.extend([4,5])
print(list_1)

顯示結果

g、insert方法

insert方法是制定要插入的元素的位置，所以括號需要兩個值，否則拋出異常。

第一個是將要插入的位置，第二個是插入的元素，如果不在範圍內就將在列表末尾插入

代碼

list_1 = [True, "shuzi", 4.2, [1, 2], 5, 50, 5]
list_1.insert(4,45)
print(list_1)
list_1.insert(77,9)
print(list_1)

顯示結果

h、pop方法

pop方法是通過下標移除元素，默認沒有下標時刪除最後一個

代碼

list_1 = [True, "shuzi", 4.2, [1, 2], 5, 50, 5]
list_1.pop(3)
print(list_1)
list_1.pop()
print(list_1)

顯示結果

i、remove方法

remove方法是移除對應的元素，如果列表中不存在該元素，則拋出異常。

代碼

list_1 = [True, "shuzi", 4.2, [1, 2], 5, 50, 5]
list_1.remove(5)
print(list_1)
list_1.remove()
print(list_1)

顯示結果

j、reverse方法

reverse方法是翻轉元素的順序，所以括號裏是沒有參數的。

代碼

list_1 = [True, "shuzi", 4.2, [1, 2], 5, 50, 5]
list_1.reverse()
print(list_1)

顯示結果

k、sort方法

sort方法是排序，主要針對數字和字符，如果是其他的類型會拋出異常。

代碼

list_1 = [ 4.2, 5, 50, 5]
list_1.sort()
print(list_1)

顯示結果

四、集合（Set）

集合是一個無序的不重複元素序列，Python中的集合與數學中的集合概念差不多，集合元素之間無序，集合用大括號 {} 表示，但是集合的元素類型是有限定的，不可以有列表，

集合的特點是元素唯一，不允許重複，無序的。

1、創建

列表的創建有兩種方法元素間用逗號,分隔，分別是：大括號 { } 、set()創建

注意1：建立空集合類型，不要直接使用{}定義，因爲 { } 是用來創建一個空字典。

注意2：儘量不要用set作爲變量名，因爲當set變成變量名的時候，set()方法將不能使用

集合名 = {元素1, 元素2, 元素3, …}
集合名 = set((元素1, 元素2, 元素3, …))

代碼

set_1 = {True, "shuzi", 4.2, 5}	
set_2 = set()	#創建一個空列表，不要用{}建立空集合
set_3 = set((5, 76, 47, 3, 4,))	#創建一個帶元素的集合
print(set_1)	
print(type(set_1))
print(set_2)
print(type(set_2))
print(set_3)
print(type(set_3))

顯示結果

注意：儘量不要用set作爲變量名，因爲當set變成變量名的時候，set()方法將不能使用

2、訪問集合中的元素

set的訪問和列表不一樣，因爲set的位置是不固定的，沒有下標的概念。可以通過in查詢元素是不是在集合中，如果存在，返回True，否則返回False。

變量名 = ‘想訪問的元素’ in 集合名

代碼

set_1 = [True, "shuzi", 4.2, 5]
print(set_1[2])

顯示結果

3、賦值

set的沒有下標所以就沒有賦值這麼一說。

4、方法

講解常用的幾個方法：

[‘add’,‘clear’, ‘copy’, ‘difference’,‘discard’,‘intersection’,‘pop’,‘remove’, ‘union’]

a、add方法

add方法是能夠在集合裏面添加一個新的元素，而且位置是隨機的，括號裏面必須有一個值。

代碼

set_1 = {True, "shuzi", 4.2, 5}
set_1.add(4)
print(set_1)

顯示結果

b、clear方法

clear方法是清除列表中的所有元素，這裏說的是清除，不是刪除列表這個對象。

代碼

set_1 = {True, "shuzi", 4.2, 5}
set_1.clear()
print(set_1)

顯示結果

注意：會發現返回的是set()，而不是{}

c、copy方法

copy方法是複製整個集合給另一個集合裏。

代碼

set_1 = {True, "shuzi", 4.2, 5}
set_2 = {4,5,7,}
print(set_1)
print(set_2)
set_2 = set_1.copy()
print(set_1)
print(set_2)

顯示結果

d、difference方法

difference方法是差集，就相對於數學集合裏的差集一樣，減去相交的元素。

代碼

set_1 = {True, "shuzi", 4.2, 5}
set_2 = {4,5,7,}
print(set_1.difference(set_2))

顯示結果

e、discard方法

discard方法是移除元素，如果不存在也不報錯。

代碼

set_1 = {True, "shuzi", 4.2, 5}
set_1.discard(5)
print(set_1)
set_1.discard(7)
print(set_1)

顯示結果

f、intersection方法

intersection方法是交集，就相對於數學集合裏的交集一樣。

代碼

set_1 = {True, "shuzi", 4.2, 5}
set_2 = {4,5,7,}
print(set_1.intersection(set_2))

顯示結果

g、union方法

union方法是並集，就相對於數學集合裏的並集一樣。

代碼

set_1 = {True, "shuzi", 4.2, 5}
set_2 = {4,5,7,}
print(set_1.union(set_2))

顯示結果

h、pop方法

pop方法是隨機移除，一般不用。

代碼

set_1 = {True, "shuzi", 4.2, 5}
set_1.pop()
print(set_1)

顯示結果

i、remove方法

remove方法是移除對應的元素，如果集合中不存在該元素，則拋出異常。

代碼

set_1 = {True, "shuzi", 4.2, 5}
set_1.remove(5)
print(set_1)
set_1.remove(8)
print(set_1)

顯示結果

五、元組（tuple）

元組是一種列表類型，一旦創建就不能被修改，可以理解爲不可變的列表。即元組由若干逗號分隔的值組成。

1、創建

元組的創建有兩種方法元素間用逗號,分隔，分別是：小括號()或 tuple()創建

元組名 = (元素1, 元素2, 元素3, …)
元組名 = tuple((元素1, 元素2, 元素3, …))

代碼

tuple_1 = [True, "shuzi", 4.2, [1, 2], 5]	#利用弱數據類型語言的特點創建一個帶元素元組
tuple_2 = tuple()	#創建一個空元組，這樣好像沒多大用處。
tuple_3 = tuple((5, 76, 47, 3, 4,))	#創建一個帶元素的元組
print(tuple_1)	
print(type(tuple_1))
print(tuple_2)
print(type(tuple_2))
print(tuple_3)
print(type(tuple_3))

顯示結果

注意：儘量不要用tuple作爲變量名，因爲當tuple變成變量名的時候，tuple()方法將不能使用

2、訪問元組中的元素

元組的訪問和列表一樣，一般通過下標訪問。

元組名[下標]

代碼

tuple_1 = (True, "shuzi", 4.2, [1, 2], 5)
print(tuple_1[2])

顯示結果

3、賦值

由於元組一旦創建就不能被修改，所以是改變不了裏面元素的。

4、方法

由於元組的方法比較多，就不一一講解了，主要講解以下常用的幾個方法： [‘count’, 'index’]

a、count方法

count方法是統計元素在元組中的個數。

代碼

tuple_1 = (True, "shuzi", 4.2, [1, 2], 5)
print(tuple_1.count(5))

顯示結果

b、index方法

index方法是查詢元素在元組中第一次出現的下標位置，如果元組中不存在該元素，則拋出異常。

代碼

tuple_1 = (True, "shuzi", 4.2, [1, 2], 5, 5, 50, 5)
print(tuple_1.index(5))
print(tuple_1.index(7))

顯示結果

六、字典（dict）

字典是用來存取多個值，按照key : value的格式存值，取的時候可以通過key而不是value去取值，key對value具有描述性的作用。存放數據的種類各種各樣並且數據較多，存在對應關係的時候可以使用字典。

在{}內用逗號分隔開多個元素，每一個元素都是key: value的格式，其中value是任意格式的數據類型，key由於具有描述性的作用，所以key通常是字符串類型。

鍵必須是唯一的，值可以取任何數據類型，但鍵必須是不可變的，如字符串，數字或元組。

1、創建

字典的創建有兩種方法元素間用逗號,分隔，分別是：中括號{}或 dict()創建

字典名 = {key1: 數據1, key2: 數據2, key3: 數據3,…}
字典名 = tuple({key1: 數據1, key2: 數據2, key3: 數據3,…})

代碼

dict_1 = {"蘋果": 10, "香蕉": 50, "橘子": 90, "西瓜": 30, "葡萄": 60}	#利用弱數據類型語言的特點創建一個帶元素字典
dict_2 = dict()	#創建一個空字典
dict_3 = dict({"香蕉": 50, "橘子": 90, "蘋果": 10, "西瓜": 30, "橘子": 90, "葡萄": 60})	#創建一個帶元素的字典
print(dict_1)	
print(type(dict_1))
print(dict_2)
print(type(dict_2))
print(dict_3)
print(type(dict_3))

顯示結果

注意1：儘量不要用dict作爲變量名，因爲當dict變成變量名的時候，dict()方法將不能使用

注意2：Python中的字典類型，key必須是字符串！！！

2、訪問字典中的元素

字典訪問元素是通過key的對應關係訪問的。

字典名[key]

代碼

dict_1 = dict({"香蕉": 50, "香蕉": 90, "蘋果": 10, "西瓜": 30, "橘子": 90, "葡萄": 60})
print(dict_1["香蕉"])

顯示結果

注意：如果key值相同，那麼訪問最後一個key值的數據

3、賦值

字典賦值是通過key來賦值的，如果key不存在，則新增這個鍵值對，如果賦值重複，則將相同key重合並賦值。

字典名[key] = 新值

代碼

dict_1 = dict({"香蕉": 50, "香蕉": 90, "蘋果": 10, "西瓜": 30, "橘子": 90, "葡萄": 60})
dict_1["香蕉"] = 100
print(dict_1)

顯示結果

4、方法

由於字典的方法比較多，就不一一講解了，主要講解以下常用的幾個方法： [‘clear’, 'copy’, ‘fromkeys’, ‘get’, ‘items’, ‘keys’, ‘pop’, ‘popitem’, ‘values’]

a、clear方法

clear方法是清除列表中的所有元素，這裏說的是清除，不是刪除列表這個對象。

代碼

dict_1 = dict({"香蕉": 50, "香蕉": 90, "蘋果": 10, "西瓜": 30, "橘子": 90, "葡萄": 60})
print(dict_1.clear())

顯示結果

b、copy方法

copy方法是複製整個集合字典給另一個字典裏。而字典間的賦值不同，賦值是一個字典有兩個名字，有點像Linux裏面的軟鏈接，copy方法是一個名字一個單獨不相干的字典。
代碼

dict_1 = dict({"香蕉": 50, "香蕉": 90, "蘋果": 10, "西瓜": 30, "橘子": 90, "葡萄": 60})
dict_2 = dict({"西瓜": 40, "龍眼": 100, "龍眼": 15, "草莓": 60})
dict_3 = dict({"西瓜": 40, "龍眼": 100, "龍眼": 15, "草莓": 60})
print(dict_1)
print(dict_2)
dict_2 = dict_1.copy()
dict_3 = dict_1
dict_2["蘋果"] = 1000000
dict_3["蘋果"] = 88888888
print(dict_1)
print(dict_2)
print(dict_3)

顯示結果

c、fromkeys方法

fromkeys方法是創建一個新字典，以序列seq中元素做字典的鍵，val爲字典所有鍵對應的初始值。

代碼

dict_1 = dict.fromkeys(["香蕉", "蘋果", "西瓜"], None)
print(dict_1)

顯示結果

d、get方法

get方法是通過key返回該key對應的值，如果沒有這個key，則返回None。

代碼

dict_1 = dict({"香蕉": 50, "香蕉": 90, "蘋果": 10, "西瓜": 30, "橘子": 90, "葡萄": 60})
print(dict_1.get("香蕉"))
print(dict_1.get(90))

顯示結果

e、items方法

items方法是以列表返回可遍歷的(鍵, 值) 元組數組。

代碼

dict_1 = dict({"香蕉": 50, "香蕉": 90, "蘋果": 10, "西瓜": 30, "橘子": 90, "葡萄": 60})
print(dict_1.items())

顯示結果

f、keys方法

keys方法是以列表返回可遍歷的鍵的數組。

代碼

dict_1 = dict({"香蕉": 50, "香蕉": 90, "蘋果": 10, "西瓜": 30, "橘子": 90, "葡萄": 60})
print(dict_1.keys())

顯示結果

g、pop方法

pop方法是刪除字典給定鍵 key 所對應的值，返回值爲被刪除的值，key值必須給出，否則拋出異常。

代碼

dict_1 = dict({"香蕉": 50, "香蕉": 90, "蘋果": 10, "西瓜": 30, "橘子": 90, "葡萄": 60})
dict_1.pop("香蕉")
print(dict_1)

顯示結果

h、popitem方法

popitem方法是隨機返回並刪除字典中的一對鍵和值。

代碼

dict_1 = dict({ "香蕉": 90, "蘋果": 10, "西瓜": 30, "橘子": 90, "葡萄": 60})
dict_1.popitem()
print(dict_1)

顯示結果

i、values方法

values方法是移除對應的元素，如果集合中不存在該元素，則拋出異常。

代碼

dict_1 = dict({ "香蕉": 90, "蘋果": 10, "西瓜": 30, "橘子": 90, "葡萄": 60})
dict_1.values()
print(dict_1)

顯示結果

Python學習之容器

一、容器

二、序列

三、列表（list）

1、創建

2、訪問列表中的元素

3、賦值

4、方法

a、append方法

b、clear方法

c、copy方法

d、count方法

e、index方法

f、extend方法

g、insert方法

h、pop方法

i、remove方法

j、reverse方法

k、sort方法

四、集合（Set）

1、創建

2、訪問集合中的元素

3、賦值

4、方法

a、add方法

b、clear方法

c、copy方法

d、difference方法

e、discard方法

f、intersection方法

g、union方法

h、pop方法

i、remove方法

五、元組（tuple）

1、創建

2、訪問元組中的元素

3、賦值

4、方法

a、count方法

b、index方法

六、字典（dict）

1、創建

2、訪問字典中的元素

3、賦值

4、方法

a、clear方法

b、copy方法

c、fromkeys方法

d、get方法

e、items方法

f、keys方法

g、pop方法

h、popitem方法

i、values方法