本文基于python 3.5.1

python常見的數據類型有字串、列表、元組、字典等，本文將詳細介紹每一種數據類型的操作方法。

一：str字串的操作方法：

1、capitalize()-->?將當前字符串第一個元素大寫顯示(如果是英文字母)，如果第一個元素是數字和特殊符號則不做任何操作，如：

1 a = "#1e23abcd" 2 print(a.capitalize()) 3 執行結果： 4 #1e23abcd 5 6 a = "abcd" 7 print(a.capitalize()) 8 執行結果： 9 Abcd Capitalize

?2、casefold()-->將所有大寫轉換為小寫，如：

1 a = "123ABCDasd123" 2 print(a.casefold()) 3 執行結果： 4 123abcdasd123 Casefold

3、center()-->以填充的方式讓字符居中，可以自定義寬度和填充物，如：

1 a = "123ABCDasd123" 2 print(a.center(50,"#")) 3 執行結果： 4 ##################123ABCDasd123################### Center

4、count()-->統計某個元素在字符串出現的次數，可以指定開始和結束的位置，如下：

1 a = "123ABCDasd123" 2 print(a.count("1",0,40)) #統計1出現多少次，從0到第40個元素，可以超出元素的長度 3 4 執行結果； 5 2 Count

5、encode()-->以指定編碼的方式顯示字串，python3當中默認為utf-8，python2當中默認為ASCII，如下：

1 a = "123ABCDasd123" 2 print(a.encode(encoding='utf-8')) 3 4 執行結果如下： 5 b'123ABCDasd123' Encode

6、endswith()-->判斷是否以指定的字符串結尾，是返回True，不是凡是False，如下：

1 a = "123ABCDasd123" 2 print(a.endswith("3")) 3 print(a.endswith("4")) 4 5 執行結果如下： 6 True 7 False Endwith

7、expandtabs-->把tab鍵換成空格，默認是8個空格，如下：

1 a = "123AB CDasd123" 2 print(a.expandtabs()) 3 4 執行結果如下: 5 123AB CDasd123 Expandtabs

?8、find()-->查找指定字符并返回第一個出現的元素下標位置，區分大小寫，如：

1 a = "123ABCDasd123" 2 print(a.find("a")) 3 4 執行結果： 5 7 find

?9、format-->將字串格式化輸出，如：

1 name="jack" 2 age=18 3 print('{0} is {1} years old. '.format(name, age)) format

?10、format_map-->與format類似，做字符串輸出格式化顯示，使用場景比較限制:

1 class Info: 2 def __init__(self, name, n): 3 self.name = name 4 self.n = n 5 s = "{name} has {n} yers" #調用的適合用大括號引起來 6 a = Info('jack',18) 7 print(s.format_map(vars(a))) #可以配合類同時傳遞多個變量，調用者需要在大括號引起來 8 9 執行結果： 10 jack has 18 yers format_map

11、index-->找到指定第一個出現的元素并返回下標，功能同find,如：

1 a = "123ABCDasd123" 2 print(a.index("a")) 3 4 執行結果： 5 7 index

12、isalnum-->判斷字符串是否全部是字母和數字組成，如果包含特殊符號返回False，完全是數字或字母返回True,如：

1 a = "123ABCDasd123" 2 b = "b123b" 3 c = "123#x" 4 print(a.isalnum()) 5 print(b.isalnum()) 6 print(c.isalnum()) 7 8 執行結果： 9 True 10 True 11 False isalnum

13、isalpha()-->判斷字符串是否只有字符組成，不區分大小寫，如下：

1 a = "ABCD" 2 b = "abc" 3 c = "1234abc56" 4 print(a.isalpha()) 5 print(b.isalpha()) 6 print(c.isalpha()) 7 8 執行結果： 9 True 10 True 11 False isalpha

14、isdecimal-->判斷字符串是否只有0-9數字(只能判斷整數)組成，如下：

1 a = "ABCD" 2 b = "123abc" 3 c = "123456" 4 print(a.isdecimal()) 5 print(b.isdecimal()) 6 print(c.isdecimal()) 7 8 執行結果： 9 False 10 False 11 True isdecimal

15、isdigit-->判斷字符串是否只有數字組成，功能同isdecimal，如下：

1 a = "ABCD" 2 b = "123" 3 c = "123456.1" 4 print(a.isdigit()) 5 print(b.isdigit()) 6 print(c.isdigit()) 7 8 執行結果： 9 False 10 True 11 False isdigit

16、isidentifier-->判斷字符串是否合法，字符串不能包含特殊符號，有漢字、大小寫英文字母和數字組成的算是合法，合法即返回Ture，反之返回False，如下：

a = "ABCD123aa" b = "你好aa123" c = "你好,hello" print(a.isidentifier()) print(b.isidentifier()) print(c.isidentifier())執行結果： True True False isidentifier

17、islower-->判斷字符串中的字母是否只有小寫字母組成，是返回Ture，否返回False，不會判斷字符串中的數字和特殊符號，如下：

1 a = "ABCD123aa" 2 b = "aa123,#" 3 c = "abcdABCD" 4 print(a.islower()) 5 print(b.islower()) 6 print(c.islower()) 7 8 執行結果： 9 False 10 True 11 False islower

18、isnumeric-->判斷字符串是否使用數字組成，功能同isdigit和isdecimal，如下：

1 a = "ABCD123aa" 2 b = "123" 3 c = "abcdABCD" 4 print(a.isnumeric()) 5 print(b.isnumeric()) 6 print(c.isnumeric()) 7 8 執行結果： 9 False 10 True 11 False isnumeric

19、isprintable-->判斷字符串的所有元素是否全部可打印，字符串包含不可打印字符（如換行符\n等），沒有不可打印(print)返回True，反之返回False，如下：

1 a = "ABCD123aa$!" 2 b = "123\n" 3 c = "abcdABCD" 4 print(a.isprintable()) 5 print(b.isprintable()) 6 print(c.isprintable()) 7 8 執行結果： 9 True 10 False 11 True isprintable

20、isspace-->判斷一個字符串是否是一個空格，是返回True，否返回Flase，如下:

1 a = "ABCD123aa$!" 2 b = " " 3 c = " a bcd" 4 5 執行結果： 6 False 7 True 8 False isspace

21、istitle-->判斷字符串當中每個單詞的首字母是否大寫，首單詞前面可以有中文或特殊符號，不受影響，只判斷每個單子首字母，是返回True，否返回False，如下：

1 a = "ABCD123Aa" 2 b = "你好，Hello" 3 c = "Hello，hello" 4 print(a.istitle()) 5 print(b.istitle()) 6 print(c.istitle()) 7 8 執行結果如下： 9 False 10 True 11 False istitle

?22、isupper-->判讀字符串當中的英文字符是否全部是大寫，不會判斷漢字和特殊符號，是返回True，否返回False，如下：

1 a = "ABCD123A" 2 b = "Hello" 3 c = "Hello，hello" 4 print(a.isupper()) 5 print(b.isupper()) 6 print(c.isupper()) 7 8 執行結果： 9 True 10 False 11 False isupper

23、join-->以指定的字串為分隔符，對字符串進行分割，在每兩個字符串之間添加指定的分割符，如下：

1 a = "ABCD123A,你好!" 2 print("#".join(a)) 3 4 執行結果： 5 A#B#C#D#1#2#3#A#,#你#好#! join

24、ljust-->返回一個靠左對齊的自定義長度的字符串，自定義長度要大于原字符串的len長度，多余的長度用空表示，如下：

1 a = "ABCD123A,你好!" 2 print(a.ljust(1000)) 3 4 執行結果： 5 ABCD123A,你好! ljust

25、lower-->將字符串內的所有大寫字母轉換為小寫字母，如下：

1 a = "xxxxFFF" 2 print(a.lower()) 3 4 #執行結果： 5 xxxxfff lower

26、lstrip-->從左側開始匹配指定的字符串，直到遇到非指定內的字串的時候終止，并顯示第一個非指定范圍內的字符到最右側最后一個，即一旦匹配到非在指定字串就停止匹配，如下：

1 a = "aaaabbbbbbbbbbbbbbbbacdb abcd bbccabc" 2 print(a.lstrip("abc")) 3 4 執行結果： 5 db abcd bbccabc lstrip

27、maketrans-->替換指定的字串，要結合translate配合使用才行，如下：

1 c = str.maketrans('oW','yp',"e") #原字符為oW，要替換為yp，并把e刪除 2 a = "Hello,WOrd" 3 print(a.translate(c)) 4 5 執行結果： 6 Hlly,pOrd translate

28、partition-->從左側開始，以指定的元素對字符串進行分割，一旦找到第一個匹配元素就進行分割，分為字串前部分，字串本身和字串的后部分，如下：

1 a = "abbcd b12345" 2 print(a.partition("b")) 3 4 執行結果： 5 ('a', 'b', 'bcd b12345') partition

29、replace-->通過指定元素對字符串當中的匹配元素進行替換，默認左側開始匹配，可以指定替換的次數，即替換幾個，如下：

1 1 a = "abbcd b1234bb5" 2 2 print(a.replace("b","x",3)) 3 3 4 4 執行結果： 5 5 axxcd x1234bb5 replace

30、rfind-->從右側開始匹配指定的元素，類似于find，如果找不到指定的元素則返回-1，找到第一個就不再繼續查找并顯示改元素從作開始的下標位，如下：

1 1 a = "ababcd b1234bb5" 2 2 print(a.rfind("a")) 3 3 print(a.rfind("x")) 4 4 5 5 6 6 執行結果： 7 7 2 #找到第一個匹配的a的下標2，很明顯是從左側開始的下標 8 8 -1 #找不到v就返回-1 rfind

31、rindex-->從右側開始查找指定的元素，找到后顯示該元素從左側開始的下邊，找不到就保錯，如下：

1 a = "ababcd b1234bb5"2 print(a.rindex("a"))3 print(a.rindex("d"))4 print(a.rindex("y"))5 6 執行結果：7 2 #a的下標8 5 #b的下標9 Traceback (most recent call last): #v找不到 10 File "C:/Users/zhang/PycharmProjects/python3-s12/day2/test1.py", line 7, in <module> 11 print(a.rindex("y")) 12 ValueError: substring not found rindex

32、rjust-->返回一個靠右對齊的自定義長度的字符串，自定義長度要大于原字符串的len長度，多余的長度用空表示，與ljust相反，如下：

1 a = "ABCD123A,你好!" 2 print(a.rjust(50)) 3 4 執行結果： 5 ABCD123A,你好! rjust

33、rpartition-->與partition相反，從右側開始匹配指定元素，一旦找到指定元素就停止匹配并對字符串進行分割，分為字串前部分，字串本身和字串的后部分，如下：

1 a = "xababcd b1234bb5" 2 print(a.rpartition("x")) 3 print(a.rpartition("1")) 4 5 執行結果： 6 ('', 'x', 'ababcd b1234bb5') #到最后如果匹配不到就為空 7 ('xababcd b', '1', '234bb5') #找到后以指定字符匹配 rpartition

34、rsplit-->從右側開始匹配，每找到一個匹配的元素，就將字符串切分一個列表，可以指定要切分幾個結果，默認包含不固定的切分結果，如下：

1 a = "xababcdb1234bb5bbbn" 2 print(a.rsplit("b")) 3 4 執行結果： 5 ['xa', 'a', 'cd', '1234', '', '5', '', '', 'n'] rsplit

35、rstrip-->功能與lstrip相同，只是從右側開始匹配，直到遇到非指定的字串結束，并顯示從非指定字串到最左側的所有字串，如下：

1 a = "aaaabbbbbbbbbbbbbbbbacdb abcd bbccabc" 2 print(a.rstrip("abc")) 3 4 執行結果： 5 aaaabbbbbbbbbbbbbbbbacdb abcd #從右側開始匹配，遇到空格即停止匹配并輸出左側的所有字串 rstrip

36、split-->與rsplit功能一樣，從左側開始匹配，每找到一個匹配的元素，就將字符串切分一個列表，可以指定要切分幾個結果，默認包含不固定的切分結果，如下：

1 a = "xababcdb1234bb5bbbn"2 print(a.split("b"))3 print(a.rsplit("b"))4 print(a.split("b",2))5 print(a.rsplit("b",2))6 7 執行結果：8 ['xa', 'a', 'cd', '1234', '', '5', '', '', 'n'] #split的分割結果，9 ['xa', 'a', 'cd', '1234', '', '5', '', '', 'n'] #rsplit的切分結果，默認分割和split沒有區別 10 ['xa', 'a', 'cdb1234bb5bbbn'] #split指定切分2個結果 11 ['xababcdb1234bb5b', '', 'n'] #rsplit指定切分2個結果后這兩個方法的結果就大不一樣了 split

37、splitlines-->拆分多行為一個列表，每行為列表中的一個元素，如下：

1 1 a = """xabab 2 2 cdb12 3 3 34bb5 4 4 bbbn""" 5 5 6 6 print(a.splitlines()) 7 7 8 8 執行結果： 9 9 ['xabab', 'cdb12', '34bb5', 'bbbn'] splitlines

38、startswith-->判斷是否以指定字符開頭，可以指定開始和結束的元素下標，是返回True，否返回False，如下：

1 a = "xababcdb1234bb5bbbn" 2 print(a.startswith("c",5,20)) #判斷第五個元素到底20個元素是否以c開頭 3 4 執行結果： 5 True #第五個元是以c開頭 startswith

39、strip-->功能同lstip和rstrip，只是從兩側匹配,遇到指定范圍外的字串即停止，如下：

1 a = "aaaabbbbbbbbbbbbbbbbacdb abcd bbccabc" 2 print(a.strip("abc")) 3 4 執行結果： 5 db abcd strip

40、swapcase-->將字符串中的小寫轉換為大寫，大寫轉換為小寫，即大小寫互為轉換，如下：

1 1 a = "xababcdb1234bACDFbbbn" 2 2 print(a.swapcase()) 3 3 4 4 執行結果： 5 5 XABABCDB1234BacdfBBBN swapcase

41、title-->將所有單詞的首字符轉換為大寫，如果首字母是特殊符號則不處理，如下：

1 a = "Hello,#WOrd" 2 b = "#Hello,worD" 3 print(a.title()) 4 print(b.title()) 5 6 執行結果： 7 Hello,#Word 8 #Hello,Word title

42、translate-->對字符串進行替換，配合maketrans()，有三個參數，第一個是原字符，第二個是新字符，第三個是要刪除的字符，如下：

1 c = str.maketrans('oW','yp',"e") #原字符為oW，要替換為yp，并把e刪除 2 a = "Hello,WOrd" 3 print(a.translate(c)) 4 5 執行結果： 6 Hlly,pOrd #e被刪除了，o成了y，W替換為了p translate

43、upper-->將所有字符轉換為大寫，如下：

1 a = "Hello,WOrd" 2 print(a.upper()) upper

44、zfill-->用戶對數字進行格式化顯示，可以顯示指定長度的一組數字，當數字長度不夠指定的長度是最左側用0填充，如下：

1 a = "123" 2 b = "#ab#" 3 print(a.zfill(2)) 4 print(a.zfill(5)) 5 print(b.zfill(8)) 6 7 執行結果； 8 123 #大于指定長度是顯示原字串 9 00123 #長度不夠市最左側填充0 10 0000#ab# #字母也可以格式化輸出 zfill

??

二：列表的操作方法：

1.?append(self, p_object)：將元素附加到列表最末端側：

list1 = [1,2,3,"a","b","jack"] print(list1,"原列表") list1.append("tom") print(list1,"append之后的列表")執行結果： [1, 2, 3, 'a', 'b', 'jack'] 原列表 [1, 2, 3, 'a', 'b', 'jack', 'tom'] append之后的列表 append

2.clear(self)：清空列表：

list1 = [1,2,3,"a","b","jack"] print(list1,"原列表") list1.clear() print(list1,"clear之后的列表")執行結果： [1, 2, 3, 'a', 'b', 'jack'] 原列表 [] clear之后的列表 clear

3.?copy(self):淺copy，只copy第一層，列表內部的字典或列表都指向原列表：

list1 = [1,2,3,"a","b","jack",(1,2,3),{"name":"jack"}] print(list1,"原列表") list2 = list1.copy() print(id(list1),"原列表的id") print(id(list2),"復制后的列表的id")print(id(list1[6]),"列表里的元組(1,2,3)") print(id(list2[6]),"copy列表里的元組(1,2,3)")print(id(list1[7]),"原列表里面的字典{'name': 'jack'}") print(id(list2[7]),"copy列表里面的字典{'name': 'jack'}")執行結果： [1, 2, 3, 'a', 'b', 'jack', (1, 2, 3), {'name': 'jack'}] 原列表 4323793288 原列表的id 4323793160 復制后的列表的id 4323754488 列表里的元組(1,2,3) 4323754488 copy列表里的元組(1,2,3) 4320781384 原列表里面的字典{'name': 'jack'} 4320781384 copy列表里面的字典{'name': 'jack'} copy

?4.count(self, value)：統計列表中某個元素出現的次數：

1 list1 = [1,2,3,"a","b","jack",(1,2,3),{"name":"jack"}] 2 print(list1.count("a")) 3 4 執行結果： 5 1 count

5.extend(self, iterable):對列表擴展，和append類似，只是extend不會元組的()、字典的 {}、列表的 []添加到原列表，也就是指附加元素，如：

#################附加元組或添加元組 list1 = [1,2,3,"a","b","jack",(1,2,3),{"name":"jack"}] list1.extend("a") tuple1 = (1,1,1,"tuple") print(list1,"原列表") list1.extend(tuple1) #擴展元組會將元組的元素添加到列表,不包含元素的括號 print(list1,"extend元組之后的") list1.append(tuple1) #append方法會將元組的括號和元素都附加到列表 print(list1,"append元組之后的")執行結果： [1, 2, 3, 'a', 'b', 'jack', (1, 2, 3), {'name': 'jack'}, 'a'] 原列表 [1, 2, 3, 'a', 'b', 'jack', (1, 2, 3), {'name': 'jack'}, 'a', 1, 1, 1, 'tuple'] extend元組之后的 [1, 2, 3, 'a', 'b', 'jack', (1, 2, 3), {'name': 'jack'}, 'a', 1, 1, 1, 'tuple', (1, 1, 1, 'tuple')] append元組之后的#################附加字典或添加字典 list1 = [1,2,3,"a","b","jack",(1,2,3),{"name":"jack"}] list1.extend("a") list2 = [5,6,7] dict1 = {"age":18} print(list1,"原列表") list1.extend(dict1) #擴展字典只會擴展字典的key,而不會擴展字典的value,也不包含字典的{} print(list1,"extend字典之后的") list1.append(dict1) #append字典會將字典的key和value和{}都添加到原列表 print(list1,"append字典之后的")執行結果： [1, 2, 3, 'a', 'b', 'jack', (1, 2, 3), {'name': 'jack'}, 'a'] 原列表 [1, 2, 3, 'a', 'b', 'jack', (1, 2, 3), {'name': 'jack'}, 'a', 'age'] extend字典之后的 [1, 2, 3, 'a', 'b', 'jack', (1, 2, 3), {'name': 'jack'}, 'a', 'age', {'age': 18}] append字典之后的#################附加列表或添加列表 list1 = [1,2,3,"a","b","jack",(1,2,3),{"name":"jack"}] list1.extend("a") list2 = [5,6,7] dict1 = {"age":18} print(list1,"原列表") list1.extend(list2) #擴展列表會將該列表的元素添加到原列表 print(list1,"extend列表之后的") list1.append(list2) #append類別會將列表和列表的[]添加到原列表 print(list1,"append列表之后的")執行結果： [1, 2, 3, 'a', 'b', 'jack', (1, 2, 3), {'name': 'jack'}, 'a'] 原列表 [1, 2, 3, 'a', 'b', 'jack', (1, 2, 3), {'name': 'jack'}, 'a', 5, 6, 7] extend列表之后的 [1, 2, 3, 'a', 'b', 'jack', (1, 2, 3), {'name': 'jack'}, 'a', 5, 6, 7, [5, 6, 7]] append列表之后的 extend 和append的區別

?6.ndex(self, value, start=None, stop=None):根據元素的名稱獲取該元素在列表的下標，如果列表當中沒有此元素則拋出ValueError: '**' is not in list，如：

a = ["a","b","c","d","e",] print(a.index("d",1,9)) #找出元素d的下標，從下標1到下標9，下標可以超出范圍不報錯 執行結果： 3 #元素的下標位置 index

7.insert(self, index, p_object):

a = ["a","b","c","d","e",] print(a,"inser之前") a.insert(0,"d") print(a,"insert之后")執行結果： ['a', 'b', 'c', 'd', 'e'] inser之前 ['d', 'a', 'b', 'c', 'd', 'e'] insert之后 insert

8.pop(self, index=None)：刪除指定下標位的元素并返回刪除的元素值，默認為刪除最后一個值：

a = ["a","b","c","d","e",] print(a,"pop之前") a.pop() print(a,"隨機pop之后") print(a,"指定元素pop之前") a.pop(2) print(a,"指定pip第二個下標位的元素之后,")執行結果： ['a', 'b', 'c', 'd', 'e'] pop之前 ['a', 'b', 'c', 'd'] 隨機pop之后 ['a', 'b', 'c', 'd'] 指定元素pop之前 ['a', 'b', 'd'] 指定pip第二個下標位的元素之后，看到第二個元素c被刪除了 pop

9.remove(self, value)：根據元素的值刪除元素切沒有返回值，如果要刪除的值不存在則返回ValueError，如：

a = ["a","b","c","d","e",] print(a,"remove之前") a.remove("d") print(a,"remove之后")執行結果： ['a', 'b', 'c', 'd', 'e'] remove之前 ['a', 'b', 'c', 'e'] remove之后 remove

10.reverse(self)：將列表反序顯示，即最前面的放在最后面，最后面的值放在最前面：

a = ["a","b","c","d","e",] print(a,"reverse之前") a.reverse() print(a,"reverse之后")執行結果： ['a', 'b', 'c', 'd', 'e'] reverse之前 ['e', 'd', 'c', 'b', 'a'] reverse之后 reverse

11.sort(self, key=None, reverse=False):對列表進行排序，如：

a = ["b","d","anja","8","5","1","0"] print(a,"sort之前的列表") a.sort() print(a,"sort之后的列表")執行結果： ['b', 'd', 'anja', '8', '5', '1', '0'] sort之前的列表 ['0', '1', '5', '8', 'anja', 'b', 'd'] sort之后的列表 #可以看到將數字和字母重新進行了排序，單詞排序按照首字母的順序進行排序 sort

?

?列列表操作：

1、列表元素賦值調用：

list1 = [('foo', 1, 2),('bar', 'hello'),('foo', 3, 4),] #定義列表 def to_foo(x, y): #定義函數print('foo-->', x, y) #打印傳遞的參數 def to_bak(s): #定義函數print('bar--->', s) #打印傳遞的參數 for a, *b in list1: #循環列表,每次一行,循環到的第一個結果賦值給a,剩下的值賦值給b,如果值是固定的,可以寫成和值一樣多得循環參數,如abcd四個一一對應4個值if a == 'foo': #假如a的結果等于footo_foo(*b) #執行to_foo函數并把實參*b傳遞給函數,另外*b的實際幾個參數要和函數需要的一直,多了少了都報錯elif a == 'bar': #如果循環到得結果是barto_bak(*b) #執行bar函數并把*b傳遞給bar函數,同上參數的數量要一直 查看代碼

?2、對類別切片賦值引用：

a = ["jack","beijing",18,"IT","Python"] name,dizhi,*other = a print("name is %s" % name) print("dizhi is %s" % dizhi) print("*other is %s " % other) print("原列表是%s " % a)執行結果: name is jack dizhi is beijing *other is [18, 'IT', 'Python'] 原列表是['jack', 'beijing', 18, 'IT', 'Python'] 切片賦值引用操作

?

三：字典：字典是無序的，在調用的時候value或key會隨機排列?

常用操作：

1.clear(self):清空列表，從字典刪除所有的鍵值對：

dict1 = {"name":"jack","age":18,"job":"IT"} print(dict1,"原列表") dict1.clear() print(dict1,"清空之后的列表")執行結果： {'name': 'jack', 'age': 18, 'job': 'IT'} 原列表 {} 清空之后的列表 clear

2.copy(self)：淺copy，只賦值第一層：

dict1 = {"name":"jack","age":18,"job":"IT"} dict2 = dict1.copy() print(id(dict1),"copy之前的字典id") print(id(dict2),"copy之后的字典id")print(id(dict1["name"]),"copy之前的dict1的value的id") print(id(dict2["name"]),"copy之后的dict2的value的id")執行結果： 4302955592 copy之前的字典id 4302955720 copy之后的字典id 4315383208 copy之前的dict1的value的id 4315383208 copy之后的dict2的value的id copy

3.fromkeys(*args, **kwargs)：以指定的序列生成新字典，key為序列的元素，value默認為None，可以為作業元素指定一個默認的value，如：

1 dict1 = dict.fromkeys(range(10),) 2 print(dict1) 3 4 執行結果： 5 {0: None, 1: None, 2: None, 3: None, 4: None, 5: None, 6: None, 7: None, 8: None, 9: None} #如果不指定value，則默認為None 6 7 #################################### 8 9 指定默認value： 10 dict1 = dict.fromkeys(range(10),"tom") 11 print(dict1) 12 13 執行結果： 14 {0: 'tom', 1: 'tom', 2: 'tom', 3: 'tom', 4: 'tom', 5: 'tom', 6: 'tom', 7: 'tom', 8: 'tom', 9: 'tom'} #如果指定value，則每個value都是相同的 fromkeys

4.get(self, k, d=None)：獲取某個key的value：

dict1 = {"name":"jack","age":18,"job":"IT"} a = dict1.get("name") print(a)執行結果: jack get

5.items(self)：返回字典的所有鍵值對：

dict1 = {"name":"jack","age":18,"job":"IT"} print(dict1.items()) #打印所有的鍵值對 for k,v in dict1.items(): #使用for循環遍歷每一鍵值對print(k,v)執行結果： dict_items([('job', 'IT'), ('age', 18), ('name', 'jack')]) #所有的鍵值對 job IT #for循環得到的的鍵值對 age 18 name jack items

6.keys(self)：顯示字典的所有的key：

dict1 = {"name":"jack","age":18,"job":"IT"} a = dict1.keys() print(a)for i in dict1.keys():print(i)執行結果： dict_keys(['job', 'age', 'name']) #所有的key job #for循環得到的key age name keys

7.pop(self, k, d=None)：刪除指定的key并返回刪除key的value：

dict1 = {"name":"jack","age":18,"job":"IT"} print(dict1,"pop之前") print(dict1.pop("age")) print(dict1,"pop之后")執行結果; {'name': 'jack', 'job': 'IT', 'age': 18} pop之前 18 {'name': 'jack', 'job': 'IT'} pop之后 pop

8.popitem(self)：隨機刪除字典的一對鍵值，并將刪除的key和value放在一個元組返回，如下：

dict1 = {"name":"jack","age":18,"job":"IT"} print(dict1,"刪除之前的字典") print(dict1.popitem(),"popitem刪除的鍵值") print(dict1,"刪除之后的字典")執行結果： {'age': 18, 'job': 'IT', 'name': 'jack'} 刪除之前的字典 ('age', 18) popitem刪除的鍵值 {'job': 'IT', 'name': 'jack'} 刪除之后的字典 popitem

9.setdefault(self, k, d=None)：為字典添加key和value的時候，判斷要加入的key名稱是否已經存在，如果已經存在字典里面則使用原字典里面的key和value，如果key不存在則使用傳遞的value并附加到字典當中，如下：

dict1 = {"name":"jack","age":18,"job":"IT"} dict1.setdefault("name","lucy") print(dict1,"添加tom之后,沒有變化")dict1.setdefault("Name","lili") print(dict1,"添加lili之后添加成功,并且字典區分大小寫")執行結果： {'job': 'IT', 'name': 'jack', 'age': 18} 添加tom之后,沒有變化 {'job': 'IT', 'name': 'jack', 'age': 18, 'Name': 'lili'} 添加lili之后添加成功,并且字典區分大小寫 setdefault

10.update(self, E=None, **F):將另外一個字典的key和value更新到本字典，如下：

dict1 = {"name":"jack","age":18,"job":"IT"} dict2 = {"Name":"tom","Age":20,"Job":"IT"}dict1.update(dict2) print(dict1)執行結果： {'name': 'jack', 'job': 'IT', 'Name': 'tom', 'Job': 'IT', 'Age': 20, 'age': 18} #將字典2全部添加到字典1，字典的key是不能重復的 update

11.values(self):返回本字典的所有key的值，即所有的value：

dict1 = {"name":"jack","age":18,"job":"IT"} dict2 = {"Name":"tom","Age":20,"Job":"IT"} dict1.update(dict2) print(dict1.values(),"value的結果")for i in dict1.values():print(i)執行結果： dict_values(['IT', 'IT', 'jack', 'tom', 18, 20]) value的結果 IT IT jack tom 18 20 values

?

轉載于:https://www.cnblogs.com/zhang-shijie/p/5129184.html

總結

以上是生活随笔為你收集整理的Python 第二篇：python字符串、列表和字典的基本操作方法的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。