Python 第二篇:python字符串、列表和字典的基本操作方法

阅读(1,659)

本文基于python 3.5.1

python常见的数据类型有字串、列表、元组、字典等,本文将详细介绍每一种数据类型的操作方法。

一:str字串的操作方法:

1、capitalize()–> 将当前字符串第一个元素大写显示(如果是英文字母),如果第一个元素是数字和特殊符号则不做任何操作,如:

a = "#1e23abcd"
print(a.capitalize())
执行结果:
#1e23abcd

a = "abcd"
print(a.capitalize())
执行结果:
Abcd

2、casefold()–>将所有大写转换为小写,如:

a = "123ABCDasd123"
print(a.center(50,"#"))
执行结果:
##################123ABCDasd123###################

3、center()–>以填充的方式让字符居中,可以自定义宽度和填充物,如:

a = "123ABCDasd123"
print(a.center(50,"#"))
执行结果:
##################123ABCDasd123###################

4、count()–>统计某个元素在字符串出现的次数,可以指定开始和结束的位置,如下:

a = "123ABCDasd123"
print(a.count("1",0,40)) #统计1出现多少次,从0到第40个元素,可以超出元素的长度

执行结果;
2

5、encode()–>以指定编码的方式显示字串,python3当中默认为utf-8,python2当中默认为ASCII,如下:

a = "123ABCDasd123"
print(a.encode(encoding='utf-8'))

执行结果如下:
b'123ABCDasd123'

6、endswith()–>判断是否以指定的字符串结尾,是返回True,不是凡是False,如下:

a = "123ABCDasd123"
print(a.endswith("3"))
print(a.endswith("4"))

执行结果如下:
True
False

7、expandtabs–>把tab键换成空格,默认是8个空格,如下: 

a = "123AB  CDasd123"
print(a.expandtabs())

执行结果如下:
123AB   CDasd123

8、find()–>查找指定字符并返回第一个出现的元素下标位置,区分大小写,如: 

a = "123ABCDasd123"
print(a.find("a"))

执行结果:
7

9、format–>将字串格式化输出,如:

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

10、format_map–>与format类似,做字符串输出格式化显示,使用场景比较限制:

class Info:
    def __init__(self, name, n):
        self.name = name
        self.n = n
s = "{name} has {n} yers" #调用的适合用大括号引起来
a = Info('jack',18)
print(s.format_map(vars(a))) #可以配合类同时传递多个变量,调用者需要在大括号引起来

11、index–>找到指定第一个出现的元素并返回下标,功能同find,如:

a = "123ABCDasd123"
print(a.index("a"))

执行结果:
7

12、isalnum–>判断字符串是否全部是字母和数字组成,如果包含特殊符号返回False,完全是数字或字母返回True,如:

a = "123ABCDasd123"
b = "b123b"
c = "123#x"
print(a.isalnum())
print(b.isalnum())
print(c.isalnum())

执行结果:
True
True
False

13、isalpha()–>判断字符串是否只有字符组成,不区分大小写,如下:

a = "ABCD"
b = "abc"
c = "1234abc56"
print(a.isalpha())
print(b.isalpha())
print(c.isalpha())

执行结果:
True
True
False

14、isdecimal–>判断字符串是否只有0-9数字(只能判断整数)组成,如下:

a = "ABCD"
b = "123abc"
c = "123456"
print(a.isdecimal())
print(b.isdecimal())
print(c.isdecimal())

执行结果:
False
False
True

15、isdigit–>判断字符串是否只有数字组成,功能同isdecimal,如下:

a = "ABCD"
b = "123"
c = "123456.1"
print(a.isdigit())
print(b.isdigit())
print(c.isdigit())

执行结果:
False
True
False

16、isidentifier–>判断字符串是否合法,字符串不能包含特殊符号,有汉字、大小写英文字母和数字组成的算是合法,合法即返回Ture,反之返回False,如下:

a = "ABCD123aa"
b = "你好aa123"
c = "你好,hello"
print(a.isidentifier())
print(b.isidentifier())
print(c.isidentifier())

执行结果:
True
True
False

17、islower–>判断字符串中的字母是否只有小写字母组成,是返回Ture,否返回False,不会判断字符串中的数字和特殊符号,如下:

a = "ABCD123aa"
b = "aa123,#"
c = "abcdABCD"
print(a.islower())
print(b.islower())
print(c.islower())

执行结果:
False
True
False

18、isnumeric–>判断字符串是否使用数字组成,功能同isdigit和isdecimal,如下:

a = "ABCD123aa"
b = "123"
c = "abcdABCD"
print(a.isnumeric())
print(b.isnumeric())
print(c.isnumeric())

执行结果:
False
True
False

19、isprintable–>判断字符串的所有元素是否全部可打印,字符串包含不可打印字符(如换行符\n等),没有不可打印(print)返回True,反之返回False,如下:

a = "ABCD123aa$!"
b = "123\n"
c = "abcdABCD"
print(a.isprintable())
print(b.isprintable())
print(c.isprintable())

执行结果:
True
False
True

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

a = "ABCD123aa$!"
b = " "
c = " a bcd"
 
执行结果:
False
True
False

21、istitle–>判断字符串当中每个单词的首字母是否大写,首单词前面可以有中文或特殊符号,不受影响,只判断每个单子首字母,是返回True,否返回False,如下:

a = "ABCD123Aa"
b = "你好,Hello"
c = "Hello,hello"
print(a.istitle())
print(b.istitle())
print(c.istitle())

执行结果如下:
False
True
False

22、isupper–>判读字符串当中的英文字符是否全部是大写,不会判断汉字和特殊符号,是返回True,否返回False,如下:

a = "ABCD123A"
b = "Hello"
c = "Hello,hello"
print(a.isupper())
print(b.isupper())
print(c.isupper())

执行结果:
True
False
False

23、join–>以指定的字串为分隔符,对字符串进行分割,在每两个字符串之间添加指定的分割符,如下: 

a = "ABCD123A,你好!"
print("#".join(a))
3 
执行结果:
A#B#C#D#1#2#3#A#,#你#好#!

24、ljust–>返回一个靠左对齐的自定义长度的字符串,自定义长度要大于原字符串的len长度,多余的长度用空表示,如下: 

a = "ABCD123A,你好!"
print(a.ljust(1000))

执行结果:
ABCD123A,你好!

25、lower–>将字符串内的所有大写字母转换为小写字母,如下:

a = "xxxxFFF"
print(a.lower())

#执行结果:
xxxxfff

26、lstrip–>从左侧开始匹配指定的字符串,直到遇到非指定内的字串的时候终止,并显示第一个非指定范围内的字符到最右侧最后一个,即一旦匹配到非在指定字串就停止匹配,如下:

a = "aaaabbbbbbbbbbbbbbbbacdb abcd bbccabc"
print(a.lstrip("abc"))

执行结果:
db abcd bbccabc

27、maketrans–>替换指定的字串,要结合translate配合使用才行,如下:

c = str.maketrans('oW','yp',"e") #原字符为oW,要替换为yp,并把e删除
a = "Hello,WOrd"
print(a.translate(c))

执行结果:
Hlly,pOrd

28、partition–>从左侧开始,以指定的元素对字符串进行分割,一旦找到第一个匹配元素就进行分割,分为字串前部分,字串本身和字串的后部分,如下:

a = "abbcd b12345"
print(a.partition("b"))

执行结果:
('a', 'b', 'bcd b12345')

29、replace–>通过指定元素对字符串当中的匹配元素进行替换,默认左侧开始匹配,可以指定替换的次数,即替换几个,如下:

a = "abbcd b1234bb5"
print(a.replace("b","x",3))

执行结果:
axxcd x1234bb5

30、rfind–>从右侧开始匹配指定的元素,类似于find,如果找不到指定的元素则返回-1,找到第一个就不再继续查找并显示改元素从作开始的下标位,如下:

a = "ababcd b1234bb5"
print(a.rfind("a"))
print(a.rfind("x"))

执行结果:
2 #找到第一个匹配的a的下标2,很明显是从左侧开始的下标
-1 #找不到v就返回-1

31、rindex–>从右侧开始查找指定的元素,找到后显示该元素从左侧开始的下边,找不到就保错,如下:

a = "ababcd b1234bb5"
print(a.rindex("a"))
print(a.rindex("d"))
print(a.rindex("y"))

执行结果:
2 #a的下标
5 #b的下标
Traceback (most recent call last): #v找不到
File "C:/Users/zhang/PycharmProjects/python3-s12/day2/test1.py", line 7, in <module>
print(a.rindex("y"))
ValueError: substring not found

32、rjust–>返回一个靠右对齐的自定义长度的字符串,自定义长度要大于原字符串的len长度,多余的长度用空表示,与ljust相反,如下:

a = "ABCD123A,你好!"
print(a.rjust(50))

执行结果:
                                      ABCD123A,你好!

33、rpartition–>与partition相反,从右侧开始匹配指定元素,一旦找到指定元素就停止匹配并对字符串进行分割,分为字串前部分,字串本身和字串的后部分,如下:

a = "xababcd b1234bb5"
print(a.rpartition("x"))
print(a.rpartition("1"))
 
执行结果:
('', 'x', 'ababcd b1234bb5')  #到最后如果匹配不到就为空
('xababcd b', '1', '234bb5') #找到后以指定字符匹配

34、rsplit–>从右侧开始匹配,每找到一个匹配的元素,就将字符串切分一个列表,可以指定要切分几个结果,默认包含不固定的切分结果,如下:

a = "xababcdb1234bb5bbbn"
print(a.rsplit("b"))
 
执行结果:
['xa', 'a', 'cd', '1234', '', '5', '', '', 'n']

35、rstrip–>功能与lstrip相同,只是从右侧开始匹配,直到遇到非指定的字串结束,并显示从非指定字串到最左侧的所有字串,如下:

a = "aaaabbbbbbbbbbbbbbbbacdb abcd bbccabc"
print(a.rstrip("abc")) 

执行结果:
aaaabbbbbbbbbbbbbbbbacdb abcd  #从右侧开始匹配,遇到空格即停止匹配并输出左侧的所有字串

36、split–>与rsplit功能一样,从左侧开始匹配,每找到一个匹配的元素,就将字符串切分一个列表,可以指定要切分几个结果,默认包含不固定的切分结果,如下:

a = "xababcdb1234bb5bbbn"
print(a.split("b"))
print(a.rsplit("b"))
print(a.split("b",2))
print(a.rsplit("b",2))

执行结果:
['xa', 'a', 'cd', '1234', '', '5', '', '', 'n'] #split的分割结果,
['xa', 'a', 'cd', '1234', '', '5', '', '', 'n'] #rsplit的切分结果,默认分割和split没有区别
['xa', 'a', 'cdb1234bb5bbbn'] #split指定切分2个结果
['xababcdb1234bb5b', '', 'n'] #rsplit指定切分2个结果后这两个方法的结果就大不一样了

37、splitlines–>拆分多行为一个列表,每行为列表中的一个元素,如下:

a = """xabab
cdb12
34bb5
bbbn"""

print(a.splitlines())

执行结果:
['xabab', 'cdb12', '34bb5', 'bbbn']

38、startswith–>判断是否以指定字符开头,可以指定开始和结束的元素下标,是返回True,否返回False,如下:

a = "xababcdb1234bb5bbbn"
print(a.startswith("c",5,20)) #判断第五个元素到底20个元素是否以c开头

执行结果:
True #第五个元是以c开头

39、strip–>功能同lstip和rstrip,只是从两侧匹配,遇到指定范围外的字串即停止,如下:

a = "aaaabbbbbbbbbbbbbbbbacdb abcd bbccabc"
print(a.strip("abc"))

执行结果:
db abcd 

40、swapcase–>将字符串中的小写转换为大写,大写转换为小写,即大小写互为转换,如下:

a = "xababcdb1234bACDFbbbn"
print(a.swapcase())
 
执行结果:
XABABCDB1234BacdfBBBN

41、title–>将所有单词的首字符转换为大写,如果首字母是特殊符号则不处理,如下:

a = "Hello,#WOrd"
b = "#Hello,worD"
print(a.title())
print(b.title())

执行结果:
Hello,#Word
#Hello,Word

42、translate–>对字符串进行替换,配合maketrans(),有三个参数,第一个是原字符,第二个是新字符,第三个是要删除的字符,如下:

c = str.maketrans('oW','yp',"e") #原字符为oW,要替换为yp,并把e删除
a = "Hello,WOrd"
print(a.translate(c))

执行结果:
Hlly,pOrd  #e被删除了,o成了y,W替换为了p

43、upper–>将所有字符转换为大写,如下:

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

44、zfill–>用户对数字进行格式化显示,可以显示指定长度的一组数字,当数字长度不够指定的长度是最左侧用0填充,如下:

a = "123"
b = "#ab#"
print(a.zfill(2))
print(a.zfill(5))
print(b.zfill(8))

执行结果;
123 #大于指定长度是显示原字串
00123 #长度不够市最左侧填充0
0000#ab# #字母也可以格式化输出

二:列表的操作方法: 

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之后的列表

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

list1 = [1,2,3,"a","b","jack"]
print(list1,"原列表")
list1.clear()
print(list1,"clear之后的列表")

执行结果:
[1, 2, 3, 'a', 'b', 'jack'] 原列表
[] 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'}

4.count(self, value):统计列表中某个元素出现的次数:

list1 = [1,2,3,"a","b","jack",(1,2,3),{"name":"jack"}]
print(list1.count("a"))

执行结果:
1

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列表之后的

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  #元素的下标位置

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之后

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被删除了

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之后

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之后

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之后的列表 #可以看到将数字和字母重新进行了排序,单词排序按照首字母的顺序进行排序

#列表操作示例:
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 = 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'} 原列表
{} 清空之后的列表

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

3.fromkeys(*args, **kwargs):以指定的序列生成新字典,key为序列的元素,value默认为None,可以为作业元素指定一个默认的value,如:

dict1 = dict.fromkeys(range(10),)
print(dict1)

执行结果:
{0: None, 1: None, 2: None, 3: None, 4: None, 5: None, 6: None, 7: None, 8: None, 9: None} #如果不指定value,则默认为None

####################################
指定默认value:
dict1 = dict.fromkeys(range(10),"tom")
print(dict1)

执行结果:
{0: 'tom', 1: 'tom', 2: 'tom', 3: 'tom', 4: 'tom', 5: 'tom', 6: 'tom', 7: 'tom', 8: 'tom', 9: 'tom'} #如果指定value,则每个value都是相同的

4.get(self, k, d=None):获取某个key的value:

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

执行结果:
jack

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

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

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之后

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'} 删除之后的字典

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之后添加成功,并且字典区分大小写

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是不能重复的

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


Warning: count(): Parameter must be an array or an object that implements Countable in /home/nginx/wordpress/wp-includes/class-wp-comment-query.php on line 405

发表评论

邮箱地址不会被公开。 必填项已用*标注