本文基于python 3.5.1

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

一:str字串的操作方法:

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

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

Capitalize

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

 a = "123ABCDasd123"
print(a.casefold())
执行结果:
123abcdasd123

Casefold

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

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

Center

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

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

Count

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

 a = "123ABCDasd123"
print(a.encode(encoding='utf-8')) 执行结果如下:
b'123ABCDasd123'

Encode

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

 a = "123ABCDasd123"
print(a.endswith(""))
print(a.endswith("")) 执行结果如下:
True
False

Endwith

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

 a = "123AB  CDasd123"
print(a.expandtabs()) 执行结果如下:
123AB CDasd123

Expandtabs

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

 a = "123ABCDasd123"
print(a.find("a")) 执行结果:
7

find

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

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

format

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))) #可以配合类同时传递多个变量,调用者需要在大括号引起来 执行结果:
jack has 18 yers

format_map

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

 a = "123ABCDasd123"
print(a.index("a")) 执行结果:
7

index

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

 a = "123ABCDasd123"
b = "b123b"
c = "123#x"
print(a.isalnum())
print(b.isalnum())
print(c.isalnum()) 执行结果:
True
True
False

isalnum

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

 a = "ABCD"
b = "abc"
c = "1234abc56"
print(a.isalpha())
print(b.isalpha())
print(c.isalpha()) 执行结果:
True
True
False

isalpha

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

 a = "ABCD"
b = "123abc"
c = ""
print(a.isdecimal())
print(b.isdecimal())
print(c.isdecimal()) 执行结果:
False
False
True

isdecimal

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

 a = "ABCD"
b = ""
c = "123456.1"
print(a.isdigit())
print(b.isdigit())
print(c.isdigit()) 执行结果:
False
True
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,不会判断字符串中的数字和特殊符号,如下:

 a = "ABCD123aa"
b = "aa123,#"
c = "abcdABCD"
print(a.islower())
print(b.islower())
print(c.islower()) 执行结果:
False
True
False

islower

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

 a = "ABCD123aa"
b = ""
c = "abcdABCD"
print(a.isnumeric())
print(b.isnumeric())
print(c.isnumeric()) 执行结果:
False
True
False

isnumeric

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

isprintable

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

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

isspace

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

 a = "ABCD123Aa"
b = "你好,Hello"
c = "Hello,hello"
print(a.istitle())
print(b.istitle())
print(c.istitle()) 执行结果如下:
False
True
False

istitle

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

 a = "ABCD123A"
b = "Hello"
c = "Hello,hello"
print(a.isupper())
print(b.isupper())
print(c.isupper()) 执行结果:
True
False
False

isupper

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

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

join

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

 a = "ABCD123A,你好!"
print(a.ljust(1000)) 执行结果:
ABCD123A,你好!

ljust

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

 a = "xxxxFFF"
print(a.lower()) #执行结果:
xxxxfff

lower

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

 a = "aaaabbbbbbbbbbbbbbbbacdb abcd bbccabc"
print(a.lstrip("abc")) 执行结果:
db abcd bbccabc

lstrip

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

 c = str.maketrans('oW','yp',"e") #原字符为oW,要替换为yp,并把e删除
a = "Hello,WOrd"
print(a.translate(c)) 执行结果:
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 a = "abbcd b1234bb5"
2 print(a.replace("b","x",3))
3
4 执行结果:
5 axxcd x1234bb5

replace

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

 1 a = "ababcd b1234bb5"
2 print(a.rfind("a"))
3 print(a.rfind("x"))
4
5
6 执行结果:
7 2 #找到第一个匹配的a的下标2,很明显是从左侧开始的下标
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相反,如下:

 a = "ABCD123A,你好!"
print(a.rjust(50)) 执行结果:
ABCD123A,你好!

rjust

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

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

rpartition

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

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

rsplit

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

 a = "aaaabbbbbbbbbbbbbbbbacdb abcd bbccabc"
print(a.rstrip("abc")) 执行结果:
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', '', '', '', '', '', 'n'] #split的分割结果,
9 ['xa', 'a', 'cd', '', '', '', '', '', 'n'] #rsplit的切分结果,默认分割和split没有区别
10 ['xa', 'a', 'cdb1234bb5bbbn'] #split指定切分2个结果
11 ['xababcdb1234bb5b', '', 'n'] #rsplit指定切分2个结果后这两个方法的结果就大不一样了

split

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

 1 a = """xabab
2 cdb12
3 34bb5
4 bbbn"""
5
6 print(a.splitlines())
7
8 执行结果:
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,只是从两侧匹配,遇到指定范围外的字串即停止,如下:

 a = "aaaabbbbbbbbbbbbbbbbacdb abcd bbccabc"
print(a.strip("abc")) 执行结果:
db abcd

strip

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

 1 a = "xababcdb1234bACDFbbbn"
2 print(a.swapcase())
3
4 执行结果:
5 XABABCDB1234BacdfBBBN

swapcase

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

 a = "Hello,#WOrd"
b = "#Hello,worD"
print(a.title())
print(b.title()) 执行结果:
Hello,#Word
#Hello,Word

title

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

translate

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

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

upper

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

 a = ""
b = "#ab#"
print(a.zfill(2))
print(a.zfill(5))
print(b.zfill(8)) 执行结果;
123 #大于指定长度是显示原字串
00123 #长度不够市最左侧填充0
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):统计列表中某个元素出现的次数:

 list1 = [1,2,3,"a","b","jack",(1,2,3),{"name":"jack"}]
print(list1.count("a")) 执行结果:
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","","","",""]
print(a,"sort之前的列表")
a.sort()
print(a,"sort之后的列表") 执行结果:
['b', 'd', 'anja', '', '', '', ''] sort之前的列表
['', '', '', '', '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 = 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,如:

 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都是相同的

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

Python 第二篇:python字符串、列表和字典的基本操作方法的更多相关文章

  1. Python数据类型-布尔/数字/字符串/列表/元组/字典/集合

    代码 bol = True # 布尔 num = 100000000; # 数字 str = "fangbei"; # 字符串 str_cn = u"你好,方倍" ...

  2. Python 整数 长整数 浮点数 字符串 列表 元组 字典的各种方法

    对于Python, 一切事物都是对象,对象基于类创建!! 注:查看对象相关成员var,type, dir 一.整数 如: 18.73.84 每一个整数都具备如下需要知道的功能: def bit_len ...

  3. Python第三天 序列 5种数据类型 数值 字符串 列表 元组 字典 各种数据类型的的xx重写xx表达式

    Python第三天 序列  5种数据类型  数值  字符串  列表  元组  字典 各种数据类型的的xx重写xx表达式 目录 Pycharm使用技巧(转载) Python第一天  安装  shell ...

  4. Python第三天 序列 数据类型 数值 字符串 列表 元组 字典

    Python第三天 序列  数据类型  数值  字符串  列表  元组  字典 数据类型数值字符串列表元组字典 序列序列:字符串.列表.元组序列的两个主要特点是索引操作符和切片操作符- 索引操作符让我 ...

  5. 第二篇 python进阶

    目录 第二篇 python进阶 一 数字类型内置方法 二 字符串类型内置方法 三 列表类型内置方法(list) 四 元组类型内置方法(tuple) 五 字典内置方法 六 集合类型内置方法(self) ...

  6. [转帖]虚拟内存探究 -- 第二篇:Python 字节

    虚拟内存探究 -- 第二篇:Python 字节 http://blog.coderhuo.tech/2017/10/15/Virtual_Memory_python_bytes/ 是真看不懂哦     ...

  7. python-字典(第二篇(四):字典)

    [Python之旅]第二篇(四):字典 摘要: 说明:     显然Python中字典的学习过程与列表是一样的,主要是围绕下面的函数来进行重点学习: 1 2 3 4 5 6 7 8 9 10 11 & ...

  8. 孤荷凌寒自学python第二十八天python的datetime.date模块

     孤荷凌寒自学python第二十八天python的datetime.date模块 (完整学习过程屏幕记录视频地址在文末,手写笔记在文末) 一.toordinal() 此方法将访问从公元1年1月1日至当 ...

  9. 孤荷凌寒自学python第二十二天python类的继承

    孤荷凌寒自学python第二十二天python类的继承 (完整学习过程屏幕记录视频地址在文末,手写笔记在文末) python中定义的类可以继承自其它类,所谓继承的概念,我的理解 是,就是一个类B继承自 ...

随机推荐

  1. iOS中怎样加入自己定义的字体

    苹果对于开发,确实在细节方面下了非常大的功夫,只是不管一个平台下多大的功夫,仍然会有些需求是无法涵盖的.比方字体吧. 我们的应用为了能更加个性化.会须要不同的字体.有时候有些字体是非常特殊的.甚至是购 ...

  2. IE浏览器下<A>标签不能显示背景图片

    修改前 background: url('./img/active/legendBg.png')no-repeat 修改后 background: url('./img/active/legendBg ...

  3. Mac Yosemite下Android Studio环境问题集合

    1. java not found 在mac Yosemite下,因jre升级到1.8,导致Android Studio无法启动.报错:"JAVA not found". 解决方法 ...

  4. PHP自练项目中个人中心创建,修改,验证(服务器端和客户端验证)

    当注册成功到登录后进入个人中心,查看和修改自己的资料 第一步:创建个人中心: <?php //定义个常量,用来授权调用includes里面的文件 define('IN_TG',true); // ...

  5. QQ对话代码

    <li> <strong class="QQ">客服QQ</strong> <span> <a href="mqqw ...

  6. Controller.RedirectToAction 方法

    此成员被重载.有关此成员的完整信息,包括语法.用法和示例,请单击重载列表中的名称.

  7. BZOJ 1603: [Usaco2008 Oct]打谷机

    题目 1603: [Usaco2008 Oct]打谷机 Time Limit: 5 Sec  Memory Limit: 64 MB Description Farmer John有一个过时的打谷机( ...

  8. Poj 2299 Ultra-QuickSort(归并排序)

    题目链接:http://poj.org/problem?id=2299 思路分析:序列的逆序数即为交换次数,所以求出该序列的逆序数即可.根据分治法思想,序列分为两个大小相等的两部分, 分别求子序列的逆 ...

  9. Gradle 1.12 翻译——第十四章. 教程 - 杂七杂八

    有关其它已翻译的章节请关注Github上的项目:https://github.com/msdx/gradledoc/tree/1.12,或訪问:http://gradledoc.qiniudn.com ...

  10. redis研究记录

    1 redis安装 wget http://download.redis.io/redis-stable.tar.gz tar xvzf redis-stable.tar.gz cd redis-st ...