python找到字符中空格所在的位置_Python 第二篇：python字符串、列表和字典的基本操作方法...

本文基于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 True7 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 classInfo:2 def __init__(self, name, n):3 self.name =name4 self.n =n5 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 True10 True11 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 True10 True11 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 False10 False11 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 False10 True11 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 False10 True11 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 False10 True11 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 True10 False11 True

isprintable

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

1 a = "ABCD123aa$!"

2 b = " "

3 c = "a bcd"

4

5 执行结果：6 False7 True8 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 False10 True11 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 True10 False11 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

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 = """xabab2 2 cdb123 3 34bb54 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原列表的id4323793160复制后的列表的id4323754488 列表里的元组(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的结果等于foo

to_foo(*b) #执行to_foo函数并把实参*b传递给函数,另外*b的实际几个参数要和函数需要的一直,多了少了都报错

elif a == 'bar': #如果循环到得结果是bar

to_bak(*b) #执行bar函数并把*b传递给bar函数,同上参数的数量要一直

查看代码

2、对类别切片赋值引用：

a = ["jack","beijing",18,"IT","Python"]

name,dizhi,*other =aprint("name is %s" %name)print("dizhi is %s" %dizhi)print("*other is %s" %other)print("原列表是%s" %a)

执行结果:

nameisjack

dizhiisbeijing*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")

执行结果：4302955592copy之前的字典id4302955720copy之后的字典id4315383208copy之前的dict1的value的id4315383208 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 18name jack

items

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

dict1 = {"name":"jack","age":18,"job":"IT"}

a=dict1.keys()print(a)for i indict1.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 indict1.values():print(i)

执行结果：

dict_values(['IT', 'IT', 'jack', 'tom', 18, 20]) value的结果

IT

IT

jack

tom18

20

values