Python 数据类型
一：数字
1.int（整形）：
在python中我们可以对整数进行加（+）,减（-），乘（*），除（/）运算 例如：执行5+5，控制台会输出10；执行5*5，控制台会输出
int魔法方法
1 def bit_length(self): # real signature unknown; restored from __doc__ 2 """ 3 int.bit_length() -> int 4 5 number of bits necessary to represent self in binary. 6 >>> bin(37) 7 '0b100101' 8 >>> (37).bit_length() 9 6 10 """ 11 return 0
2.float（浮点数类型）
在python中带小数点的数都数浮点数类型，我们也可以对浮点型数字进行加（+），减（-），乘（*），除（/）运算
二：布尔类型
布尔类型只有true（1）和false（0）两个值
python中所有的数据类型都自带布尔值：
空列表，空字符串，空字典，none，0的布尔值都为false；其余都为true
三：序列
所谓序列类型就是系列中的每一个元素都是有编号的，其中第一个元素的编号（即索引）为0，第二个元素的编号为1，以此类推（相反最后一个元素的变化为-1，倒数第二个元素的编号为-2）。python中的序列有：列表（list），字符串（str），元组（tuple）。最大值，最小值，长度，索引，切片，相加，相乘和序列元素检查这些操作都适用于序列类型，python还提供一些内置函数，对于操作序列非常方便。
1.序列的通用操作
1）最大值和最小值
python提供的内置函数max,min非常有用，min和max分别返回系列中最小的元素和最大的元素。
1 >>> nums = [23, 34, 12, 56] 2 >>> max(nums) 3 56 4 >>> min(nums) 5 12
2）长度
python提供内置函数len可以返回序列中元素的个数。
1 >>> len(nums) 2 4
3）索引
序列中所有的元素都有一个编号（即从0开始，依次递增），例如，我们创建一个字符串’hello_python‘，字符串中索引1指向的元素是’2‘。
1 #字符串
2 >>> s = 'hello_python'
3 >>> s[1]
4 'e'
5 #列表
6 >>> l = list('python')
7 >>> l
8 ['p', 'y', 't', 'h', 'o', 'n']
9 >>> l[1]
10 'y'
11 #元组
12 >>> tu = tuple('python')
13 >>> tu
14 ('p', 'y', 't', 'h', 'o', 'n')
15 >>> tu[3]
16 'h'
python 还可以使用负数索引，从左往右（即从最后一个元素开始），-1指向最后一个元素
1 #字符串
2 >>> s = 'hello_python'
3 >>> s[-3]
4 'h'
5 #列表
6 >>> l = list(s)
7 >>> l
8 ['h', 'e', 'l', 'l', 'o', '_', 'p', 'y', 't', 'h', 'o', 'n']
9 >>> l[-2]
10 'o'
11 #元组
12 >>> tu = tuple(s)
13 >>> tu
14 ('h', 'e', 'l', 'l', 'o', '_', 'p', 'y', 't', 'h', 'o', 'n')
15 >>> tu[-1]
16 'n'
4）切片
在python我们可以使用切片的方式来访问序列中特定范围内的元素。
1 #如下字符串，我们使用两个索引，中间用冒号隔开，两个索引的区间是左闭右开（即大于等于左边的索引，小于右边的索引），因此取得切片是'hel',而不是'hell'。
2 >>> s = 'hello_python'
3 >>> s[0:3]
4 'hel'
5 #类似字符串，渠道的切片是['c++', 'c#', 'java']。
6 >>> l = ['python', 'c', 'c++', 'c#', 'java', 'php', 'go']
7 >>> l[2:5]
8 ['c++', 'c#', 'java']
9 #元组自然也是类似的结果
10 >>> tu = ('python', 'c', 'c++', 'c#', 'java', 'php', 'go')
11 >>> tu[1:3]
12 ('c', 'c++')
13
14 #但是执行切片操作是，第二个索引所指向的元素必须在第一个索引指向元素的后面，不然会得到一个空序列。例如
15 >>> l = ['python', 'c', 'c++', 'c#', 'java', 'php', 'go']
16 >>> l[4:2]
17 []
前面的切片我们取到的是索引区间中的所有元素，因为我们忽略了另一个参数（即步长）。默认情况下，步长的值为1，如果我们吧步长设置为2或3呢。
1 #第一个结果，我们将步长设置为2，切片结果就是每隔一个元素提取一个元素 2 #第二个结果，我们将步长设置为3，切片结果就是每个两个元素提取一个元素 3 #第三个结果，我们将步长设置为4，切片结果就是每个三个元素提取一个元素 4 >>> l = ['python', 'c', 'c++', 'c#', 'java', 'php', 'go'] 5 >>> l[0:6:2] 6 ['python', 'c++', 'java'] 7 >>> l[0:6:3] 8 ['python', 'c#'] 9 >>> l[0:6:4] 10 ['python', 'java']
5）序列乘法
python中只要将序列乘以一个数n，就是创建一个重复原先序列n次的新序列。
1 #字符串
2 >>> 'python' *3
3 'pythonpythonpython'
4 #列表
5 >>> ['python', 'c', 'java'] * 3
6 ['python', 'c', 'java', 'python', 'c', 'java', 'python', 'c', 'java']
7 #元组
8 >>> ('python', 'c', 'java') * 3
9 ('python', 'c', 'java', 'python', 'c', 'java', 'python', 'c', 'java')
6）序列加法
python中我们可以使用加法运算符（+）来拼接序列。但是不同的序列间的加法python不支持。
1 #字符串相加 2 >>> 'hello' + 'python' 3 'hellopython' 4 #列表 5 >>> [1,2,3] + [4,5,6] 6 [1, 2, 3, 4, 5, 6] 7 #元组 8 >>> (1,2,3) + (4,5,6) 9 (1, 2, 3, 4, 5, 6) 10 11 #不同类型的序列相加，python解释器就会报错 12 >>> 'python' + [1,2,3] 13 traceback (most recent call last): 14 file "<stdin>", line 1, in <module> 15 typeerror: must be str, not list
7）序列元素检查
python提供运算符in,来检查序列中是否包含某个特定元素，如果包含元素则返回true,反之返回false。
1 #下面字符串'he'是'hello'的成员，而'hl'不是。 2 >>> 'he' in 'hello' 3 true 4 >>> 'hl' in 'hello' 5 false 6 >>> 'java' in ['python', 'c', 'java'] 7 true
2.列表
1）修改列表元素的值
python可以直接通过索引获取列表的元素，并且直接用‘=’赋予新的值
1 >>> l = [1,2,3,4,5] 2 >>> l[3] = 9 3 >>> l 4 [1, 2, 3, 9, 5]
2）删除元素
使用del 语句就可以将列表中的元素轻松删除
1 >>> l = [1,2,3,4,5] 2 >>> del l[2] 3 >>> l 4 [1, 2, 4, 5]
3）给切片赋值
1 >>> l = [1,2,3,4,5] 2 >>> l[1:3] = [0,0] 3 >>> l 4 [1, 0, 0, 4, 5] 5 #给切片赋值，列表长度更长了 6 >>> l = [1,2,3,4,5] 7 >>> l[1:3] = [9,9,9] 8 >>> l 9 [1, 9, 9, 9, 4, 5]
4）列表方法
1 class list(object): 2 """ 3 list() -> new empty list 4 list(iterable) -> new list initialized from iterable's items 5 """ 6 def append(self, p_object): 7 # real signature unknown; restored from __doc__ 8 """ l.append(object) -> none -- append object to end """ 9 pass 10 11 def clear(self): 12 # real signature unknown; restored from __doc__ 13 """ l.clear() -> none -- remove all items from l """ 14 pass 15 16 def copy(self): 17 # real signature unknown; restored from __doc__ 18 """ l.copy() -> list -- a shallow copy of l """ 19 return [] 20 21 def count(self, value): 22 # real signature unknown; restored from __doc__ 23 """ l.count(value) -> integer -- return number of occurrences of value """ 24 return 0 25 26 def extend(self, iterable): 27 # real signature unknown; restored from __doc__ 28 """ l.extend(iterable) -> none -- extend list by appending elements from the iterable """ 29 pass 30 31 def index(self, value, start=none, stop=none): 32 # real signature unknown; restored from __doc__ 33 """ 34 l.index(value, [start, [stop]]) -> integer -- return first index of value. 35 raises valueerror if the value is not present. 36 """ 37 return 0 38 39 def insert(self, index, p_object): 40 # real signature unknown; restored from __doc__ 41 """ l.insert(index, object) -- insert object before index """ 42 pass 43 44 def pop(self, index=none): 45 # real signature unknown; restored from __doc__ 46 """ 47 l.pop([index]) -> item -- remove and return item at index (default last). 48 raises indexerror if list is empty or index is out of range. 49 """ 50 pass 51 52 def remove(self, value): 53 # real signature unknown; restored from __doc__ 54 """ 55 l.remove(value) -> none -- remove first occurrence of value. 56 raises valueerror if the value is not present. 57 """ 58 pass 59 60 def reverse(self): 61 # real signature unknown; restored from __doc__ 62 """ l.reverse() -- reverse *in place* """ 63 pass 64 65 def sort(self, key=none, reverse=false): 66 # real signature unknown; restored from __doc__ 67 """ l.sort(key=none, reverse=false) -> none -- stable sort *in place* """ 68 pass
1.append(self, p_object)
append方法用于将一个对象附加到列表的末尾（直接修改列表，而不是创建一个新的列表）。
#append方法需要我们传入一个对象作为参数（def append(self, p_object)）
>>> l = ['python', 'c', 'c++']
>>> l.append('java')
>>> l
['python', 'c', 'c++', 'java']
2.clear(self)
clear方法的作用就是清空列表
1 #直接调用clear方法就可以情况列表，无需传入参数 2 >>> l = ['python', 'c', 'c++'] 3 >>> l.clear() 4 >>> l 5 []
3.copy(self)
copy方法就是复制列表，这里的复制浅复制。与赋值跟深复制存在区别。copy方法的效果与前面讲的通用方法中的切片list[:]的效果类似
1 >>> l = ['python', 'c', 'c++', [1,2,3]] 2 >>> lst = l.copy() 3 >>> lst 4 ['python', 'c', 'c++', [1, 2, 3]] 5 >>> lst = l[:] 6 >>> lst 7 ['python', 'c', 'c++', [1, 2, 3]]
4.count(self, value)
count方法的作用是计算列表中特定元素在列表中出现的次数
1 #count需要我们传入一个value作为参数，最后将返回value在列表中出现的次数（def count(self, value)）
2 >>> l = ['python', 'c', 'c++', 'python', 'java', 'java', 'python', 'c']
3 >>> l.count('python')
4 3
5 >>> l.count('c')
6 2
5.extend(self, iterable)
用于扩展列表，前面的append方法只能添加一个元素到列表的末尾，而extend方法只需传入一个可迭代对象便可以添加多个元素到列表末尾（可以用一个列表扩展当前列表，也可以用元组，字符串，字典等）
1 #extend方法需要我们传入一个可迭代对象作为参数，extend会依次迭代出对象的元素添加到列表的末尾（def extend(self, iterable)）。
2 >>> l = ['python', 'c', 'c++']
3 >>> l.extend(['java', 'php'])
4 >>> l
5 ['python', 'c', 'c++', 'java', 'php']
6 >>> l.extend('china')
7 >>> l
8 ['python', 'c', 'c++', 'java', 'php', 'c', 'h', 'i', 'n', 'a']
9 #注意：当传入的是字典时，添加到列表的是字典的值
10 >>> l.extend({'name': 'lin', 'age': 18})
11 >>> l
12 ['python', 'c', 'c++', 'java', 'php', 'c', 'h', 'i', 'n', 'a', 'name', 'age']
6.index(self, value, start=none, stop=none)
index方法可以在列表中找到指定元素在列表中第一次出现的索引。
1 #index方法需要我们传入一个value作为参数，当参数存在时，返回第一次出现的索引
2 >>> l = ['python', 'c', 'c++', 'java', 'c', 'python', 'c']
3 >>> l.index('c')
4 1
5 >>> l.index('python')
6 0
7 #注意：当value不在列表中的时，程序将报错
8 >>> l.index('php')
9 traceback (most recent call last):
10 file "<stdin>", line 1, in <module>
11 valueerror: 'php' is not in list
12
13 #index方法我们还可以传入第二个参数（开始查找的索引），第三个参数（查找结束的索引）（def index(self, value, start=none, stop=none)）
14 >>> l = ['python', 'c', 'c++', 'java', 'c', 'python', 'c']
15 >>> l.index('c', 2, 5)
16 4
7.insert(self, index, p_object)
insert方法可以将一个随想插入列表，与append方法不同的是，insert可以在列表中的任何位置插入一个对象。
#insert需要我们传入两个参数，第一个参数为要插入索引位置，第二个参数是要插入的对象（def insert(self, index, p_object)） >>> l = ['python', 'c', 'c++'] >>> l.insert(2, 'java') >>> l ['python', 'c', 'java', 'c++'] #插入的是一个元素，并没有迭代 >>> l.insert(2, ['go', 'java']) >>> l ['java', 'python', ['go', 'java'], 'c', 'java', 'c++']
8.pop(self, index=none)
pop方法将删除列表中最后一个元素，并返回这个元素。如果传入一个索引值，将删除所以位该值的元素而不是最后一个原素。
1 >>> l = ['python', 'c', 'c++', 'java'] 2 >>> l.pop() 3 'java' 4 #pop方法我们还可以传入一个数，可指定删除索引为该数的元素，并返回这个元素，如果这个数大于等于列表的长度，将会报错（def pop(self, index=none)） 5 >>> l = ['python', 'c', 'c++', 'java'] 6 >>> l.pop(2) 7 'c++' 8 >>> l.pop(8) 9 traceback (most recent call last): 10 file "<stdin>", line 1, in <module> 11 indexerror: pop index out of range
9.remove(self, value)
remove方法可以根据特定元素的值来删除列表中一个该元素
1 #传入'c',只删除列表中第一个'c'元素（def remove(self, value)）
2 >>> l = ['python', 'c', 'c++', 'java', 'c', 'python', 'c']
3 >>> l.remove('c')
4 >>> l
5 ['python', 'c++', 'java', 'c', 'python', 'c']
6 #当该值不在列表中时，程序报错
7 >>> l.remove('go')
8 traceback (most recent call last):
9 file "<stdin>", line 1, in <module>
10 valueerror: list.remove(x): x not in list
10.reverse(self)
reverse方法将返回相反顺序的列表，直接修改原列表
1 >>> l = ['python', 'c', 'c++', 'java'] 2 >>> l.reverse() 3 >>> l 4 ['java', 'c++', 'c', 'python']
11.sort(self, key=none, reverse=false)
sort方法会对列表进行排序，直接修改原列表
1 #def sort(self, key=none, reverse=false) 2 >>> l = ['python', 'c', 'c++', 'java'] 3 >>> l.sort() 4 >>> l 5 ['c', 'c++', 'java', 'python'] 6 #我们可以传入可选参数reverse，当为true的时候，以相反的顺序排列 7 >>> l.sort(reverse = true) 8 >>> l 9 ['python', 'java', 'c++', 'c'] 10 #我看可以传入可选参数key（key可以可以设置为内置函数），这里我们设置为len函数，列表便按照元素的长度来排列 11 >>> l.sort(key = len, reverse = true) 12 >>> l 13 ['python', 'java', 'c++', 'c']
3.字符串
1.center(self, width, fillchar=none)
center方法可以设置字符串长度，添加的字符默认是空格，让字符串居中。返回的是居中后的副本，并不改变原字符串
1 #center方法需要我们传入一个参数 2 >>> s = 'python' 3 >>> s.center(15) 4 ' python ' 5 #我们还可以穿日第二个参数'*', 添加部分就用center填充 6 >>> s.center(15, '*') 7 '*****python****' 8 #原字符串没有发生改变 9 >>> s 10 'python'
2.count(self, sub, start=none, end=none)
count方法返回字符串中某一特定子串出现的次数。
1 >>> s = 'pythonpython'
2 >>> s.count('o')
3 2
3.endswith(self, suffix, start=none, end=none) 和 startswith(self, prefix, start=none, end=none)
endswith和startswith分别返回字符串是否是以某子串结束和开始。
1 >>> s = 'python'
2 >>> s.startswith('py')
3 true
4 >>> s.startswith('y')
5 false
6 >>> s.endswith('on')
7 true
8 >>> s.endswith('o')
9 false
3.find(self, sub, start=none, end=none)
find方法可以在在字符串中查找字串，类似于序列的index方法，返回子串在子串中第一次出现的索引，如果不存在就返回-1。
1 >>> s = 'python' * 3
2 >>> s
3 'pythonpythonpython'
4 #这里我们传入'th'，find方法返回'th'在字符串中第一次出现的索引
5 >>> s.find('th')
6 2
7 #当传入的字符串不是s的子串的时候，返回-1
8 >>> s.find('pth')
9 -1
10 #我们还可以传入第二个参数开始查找的索引位置，第三个参数结束查找的位置
11 >>> s.find('on', 5, 15)
12 10
4.join(self, iterable)与 split(self, chars=none)
join和split方法子字符串方法中非常重要的两个，join可以合并序列的元素，split的作用与join相反，拆分字符串。
1 >>> l = [1, 2, 3, 4]
2 >>> s = '+'
3 #合并的序列必须是字符串，不然程序就会报如下的错误
4 >>> s.join(l)
5 traceback (most recent call last):
6 file "<stdin>", line 1, in <module>
7 typeerror: sequence item 0: expected str instance, int found
8 >>> l = ['p', 'y', 't', 'h', 'o', 'n']
9 >>> ''.join(l)
10 'python'
11 >>> '+'.join(l)
12 'p+y+t+h+o+n'
13 #字符串s根据空格分裂成一个列表
14 >>> s = 'hello python world'
15 >>> s.split(' ')
16 ['hello', 'python', 'world']
5.lowe(self)， upper(self) 和 title(self)
lower方法返回字符串的小写版本，upper方法返回字符串的大写版本， title返回字符串的标题形式。原字符穿没有被重新赋值
1 >>> s = 'python' 2 #字符串字母全为小写 3 >>> s.lower() 4 'python' 5 #字符串字母全为大写 6 >>> s.upper() 7 'python' 8 #原字符串没有发生改变 9 >>> s 10 'python' 11 >>> s = 'python' 12 #字符串变为标题形式（首字母大写，其他小写） 13 >>> s.title() 14 'python' 15 #原字符串不变 16 >>> s 17 'python'
6.replace(self, old, new, count=none)
replace方法将制定子串替换为另一个字符串，并且返回替换后的结果
1 #def replace(self, old, new, count=none)，这边我们必须传入第一个参数旧的子串，第二个参数新的字符串。第三个参数为可选参数（默认为旧的子串出现的次数）
2 >>> s = 'hello python python python world'
3 >>> s.replace('python', 'java')
4 'hello java java java world'
5 #传入第三个参数为2时，replace就修改前两个python
6 >>> s.replace('python', 'java', 2)
7 'hello java java python world'
8 #传入第三个参数为2时，replace就修改第一个python
9 >>> s.replace('python', 'java', 1)
10 'hello java python python world'
7,.strip(self, chars=none)，lstrip(self, chars=none)，rstrip(self, chars=none)
strip方法将可以将字符串开头和结尾的空白处删除（不包括字符串中的字符串），返回删除后的结果。
lstrip则是删除字符串左边的空白处，rstrip是删除字符串右边的空白处。
1 >>> s = ' hello python world ' 2 >>> s.strip() 3 'hello python world' 4 >>> s.lstrip() 5 'hello python world ' 6 >>> s.rstrip() 7 ' hello python world'
8.translate(self, table)
translate方法与replace方法类似，都是替换字符串的一部分，但是replace只能替换字符串中某一特定子串，translace方法能同事替换多个子串
不过在替换之前我们需使用maketrans方法创建一个转换表（translate接收两个长度相同参数）
1 >>> table = str.maketrans('on', '**')
2 >>> s = 'hello python python python world'
3 #这里只有是o,n都被替换成*
4 >>> s.translate(table)
5 'hell* pyth** pyth** pyth** w*rld'
9.字符串的其他方法
|
4.元组
元组与列表类似，列表使用[ ]，而元组则是使用（）。还有一个差别是元组是不可修改的
1 #元组的元素间需要有一个逗号隔开，如下的代码，2后面没加逗号就是数字2，当我们加上逗号就变成了元组 2 >>> 2 3 2 4 >>> 2, 5 (2,) 6 #元组支持count(self, value)方法，计算元组中指定元素的个数 7 >>> tu = (1,2,3,4,5,3,4,5,2,2) 8 >>> tu.count(2) 9 3 10 #元组也支持index(self, value, start=none, stop=none)方法，返回指定元素在元组中第一次出现的索引 11 >>> tu.index(2) 12 1 13 当元素不在元组里是，报错 14 >>> tu.index(9) 15 traceback (most recent call last): 16 file "<stdin>", line 1, in <module> 17 valueerror: tuple.index(x): x not in tuple
四：映射-字典
1.创建字典:字典由键值对组成，每个键值对就是字典的一个元素，键值对之间用分号（：）隔开，元素之间用逗号（，）隔开。字典中的键必须是唯一且不可变得（不可以是列表或者字典）。字典中的元素是无序的。
dic = {'name': 'gumby', 'age': '18'}
2.字典的基本操作
1）使用len(dict)函数返回字典中包含的键值对的个数
1 >>> dic = {'name': 'gumby', 'age': '18'}
2 >>> len(dic)
3 2
2）dict[key]，key的值为字典中的键的名称，返回该键所对应的值
1 >>> dic = {'name': 'gumby', 'age': '18'}
2 >>> dic['name']
3 'gumby'
4 >>> dic = {'name': 'gumby', 'age': '18'}
5 >>> dic['phone'] = '123456'
6 >>> dic
7 {'name': 'gumby', 'age': '18', 'phone': '123456'}
3）dict[key] = value， 我们可以使用‘=’来给字典键为key的项关联新的值。当键不在字典中的时候，字典将添加这一键值对到字典中。
1 >>> dic = {'name': 'gumby', 'age': '18'}
2 >>> dic['name'] = 'alex'
3 >>> dic
4 {'name': 'alex', 'age': '18'}
4）使用del dict[key] 来删除键值对
1 >>> dic = {'name': 'gumby', 'age': '18', 'phone': '123456'}
2 >>> del dic['phone']
3 >>> dic
4 {'name': 'gumby', 'age': '18'}
5）成员资格：使用key in dict来检查字典中是都包含键为key的值,存在返回true，反之返回false
1 >>> dic = {'name': 'gumby', 'age': '18', 'phone': '123456'}
2 >>> 'name' in dic
3 true
4 >>> 'add' in dic
5 false
3.字典的方法
1.clear(self)
clear方法将删除字典中所有的项，原字典变为空字典
1 >>> dic = {'name': 'gumby', 'age': '18', 'phone': '123456'}
2 >>> dic.clear()
3 >>> dic
4 {}
2.copy(self)
copy方法返回一个新字典，跟原字典相同，只不过这个复制是浅复制
1 >>> dic = {'name': 'gumby', 'age': '18', 'phone': '123456'}
2 >>> dic.copy()
3 {'name': 'gumby', 'age': '18', 'phone': '123456'}
3.fromkeys(*args, **kwargs)
fromkeys方法创建一个新的字典，其中包含指定的键，对应的每个值都是一样的
1 >>> dic = {'name': 'gumby', 'age': '18', 'phone': '123456'}
2 >>> dict.fromkeys(dic)
3 {'name': none, 'age': none, 'phone': none}
4 >>> dict.fromkeys([1, 2, 3])
5 {1: none, 2: none, 3: none}
6 #传入第二个参数为‘python’，字典的每个键对应的值都为'python'
7 >>> dict.fromkeys([1, 2, 3], 'python')
8 {1: 'python', 2: 'python', 3: 'python'}
4.get(self, k, d=none)
get方法与上述的dict[keys]的效果类似，不同的是当k在字典中找不到的时候不会报错，会返回none或我们指定的值
1 >>> dic = {'name': 'gumby', 'age': '18', 'phone': '123456'}
2 >>> dic.get('name')
3 'gumby'
4 >>> dic.get('school')
5 >>> dic.get('school','nothing')
6 'nothing'
5.items(self)
items方法返回一个包含字典中所有键值对的可迭代对象，每个键值对用元组返回
1 >>> dic = {'name': 'gumby', 'age': '18', 'phone': '123456'}
2 >>> dic.items()
3 dict_items([('name', 'gumby'), ('age', '18'), ('phone', '123456')])
4 >>> list(dic.items())
5 [('name', 'gumby'), ('age', '18'), ('phone', '123456')]
6.keys(self)
keys方法返回字典中所有键组成的可迭代对象
1 >>> dic = {'name': 'gumby', 'age': '18', 'phone': '123456'}
2 >>> dic.keys()
3 dict_keys(['name', 'age', 'phone'])
4 >>> list(dic.keys())
5 ['name', 'age', 'phone']
7.pop(self, k, d=none) 与 popitem(self)
pop方法返回指定key所对应的值，并且从字典中删除该键值对；popitem方法类似于列表中的pop方法，只是列表中的pop方法是删除最后一个元素，而popitem方法是随机删除字典中的一个键值对，并返回
1 >>> dic = {'name': 'gumby', 'age': '18', 'phone': '123456'}
2 >>> dic.pop('name')
3 'gumby'
4 >>> dic
5 {'age': '18', 'phone': '123456'}
6 >>> dic = {'name': 'gumby', 'age': '18', 'phone': '123456'}
7 >>> dic.popitem()
8 ('phone', '123456')
9 >>> dic
10 {'name': 'gumby', 'age': '18'}
8.setdefault(self, k, d=none)
setdefault方法类似于get方法，可以获取指定键所对应的值，与get方法不同的是，若key不在字典中，setdefault方法将在字典中插入指定的键值对。
1 >>> dic = {'name': 'gumby', 'age': '18', 'phone': '123456'}
2 >>> dic.setdefault('name')
3 'gumby'
4 #‘school’不在该字典中，setdefault在字典中插入该键且值为none
5 >>> dic.setdefault('school')
6 >>> dic
7 {'name': 'gumby', 'age': '18', 'phone': '123456', 'school': none}
9.update(self, e=none, **f)
updat方法使用一个字典中的键值对来更新另一个字典，如果包含相同的项就替换该项的值，若不存在，就添加到字典中。
1 >>> dic = {'name': 'gumby', 'age': '18'}
2 >>> d = {'name': 'alex', 'phone': '123456'}
3 >>> dic.update(d)
4 >>> dic
5 {'name': 'alex', 'age': '18', 'phone': '123456'}
10.values(self)
values方法返回一个有字典中的值组成的可迭代对象
1 >>> dic = {'name': 'gumby', 'age': '18', 'phone': '123456'}
2 >>> dic.values()
3 dict_values(['gumby', '18', '123456'])
4 >>> list(dic.values())
5 ['gumby', '18', '123456']
五：集合
集合具有唯一性（集合中的元素各不相同），无序性，确定性（集合中的元素是不可改变的，不能是列表，字典以及集合本身）
1.add(self, *args, **kwargs)，union(self, *args, **kwargs)，update(self, *args, **kwargs)
add方法：向字典中添加一个元素，当字典中存在这个元素时，不做任何操作（只能添加一个元素）
union方法：传入一个可迭代的参数，union方法将迭代出里面的元素，更新到字典的副本中，不改变原字典（传入一个可迭代对象，添加多个元素，原字典不变）
update方法：与union方法类似，不同的是update方法修改原字典（传入一个可迭代对象，添加多个元素，修改原字典）
1 >>> set1 = {'python', 'java', 'c', 'c++'}
2 >>> set1.add('php')
3 >>> set1
4 {'c', 'c++', 'php', 'python', 'java'}
5 >>> set1.add('php')
6 >>> set1
7 {'c', 'c++', 'php', 'python', 'java'}
1 >>> set1 = {'python', 'java', 'c', 'c++'}
2 >>> set2 = {'python', 'c', 'php'}
3 >>> set1.union(set2)
4 {'java', 'c', 'c++', 'php', 'python'}
5 >>> set1.union(['linz'])
6 {'c', 'c++', 'python', 'java', 'linz'}
7 >>> set1.union('linz')
8 {'c', 'c++', 'l', 'i', 'python', 'java', 'n', 'z'}
9 #set1不发生改变
10 >>> set1
11 {'java', 'c', 'c++', 'python'}
1 >>> set1 = {'python', 'java', 'c', 'c++'}
2 >>> set1.update({'java', 'php'})
3 >>> set1
4 {'java', 'c', 'c++', 'php', 'python'}
5 >>> set1.update('123')
6 >>> set1
7 {'java', 'c', 'c++', '1', '3', 'php', '2', 'python'}
2.clear(self, *args, **kwargs)
清空字典中的所有元素
1 >>> set1 = {'java', 'c', 'c++', '1', '3', 'php', '2', 'python'}
2 >>> set1.clear()
3 >>> set1
4 set()
3.copy(self, *args, **kwargs)
与列表中的copy方法类似，返回字典的副本，同样的也是浅复制
1 >>> set1 = {'python', 'java', 'c', 'c++'}
2 >>> set1.copy()
3 {'java', 'c', 'c++', 'python'}
4 >>> set2 = set1.copy()
5 >>> set2
6 {'java', 'c', 'c++', 'python'}
4.difference(self, *args, **kwargs) 与 difference_update(self, *args, **kwargs)
求两个集合的差集。difference方法不修改set1，返回一个差集的字典副本；而difference_update方法直接修改set1，等于差集
1 >>> set1 = {'python', 'java', 'c', 'c++'}
2 >>> set2 = {'c++', 'go', 'c', 'php'}
3 >>> set1.difference(set2)
4 {'java', 'python'}
1 #set1发生改变
2 >>> set1.difference_update(set2)
3 >>> set1
4 {'java', 'python'}
5.discard(self, *args, **kwargs)，pop(self, *args, **kwargs)，remove(self, *args, **kwargs）
pop方法随机删除集合中的一个元素，当集合为空的时候程序报错
discard从集合中移除特定元素。如果元素不是该集合成员，则什么也不做。
remove从一个集合中移除一个元素，这个元素必须是集合的一个成员。如果元素不是成员，则引发键错误。
>>> set1 = {'python', 'java', 'c', 'c++'}
>>> set1.pop()
'java'
#当集合为空集时，程序报错
>>> se1 = {}
>>> se1.pop()
traceback (most recent call last):
file "<stdin>", line 1, in <module>
typeerror: pop expected at least 1 arguments, got 0
1 >>> set1 = {'python', 'java', 'c', 'c++'}
2 >>> set1.discard('python')
3 >>> set1
4 {'java', 'c', 'c++'}
5 #删除'python'之后，再次删除，程序不做任何事情
6 >>> set1.discard('python')
7 >>> set1
8 {'java', 'c', 'c++'}
1 >>> set1 = {'python', 'java', 'c', 'c++'}
2 >>> set1.remove('python')
3 >>> set1
4 {'java', 'c', 'c++'}
5 #删除'python'之后，再次删除，程序报错
6 >>> set1.remove('python')
7 traceback (most recent call last):
8 file "<stdin>", line 1, in <module>
9 keyerror: 'python'
6.intersection(self, *args, **kwargs) 与 intersection_update(self, *args, **kwargs)
求set1与set2的交集；intersection方法不修改set1，返回一个交集的字典副本；而intersection_update方法直接修改set1，等于交集
1 >>> set1 = {'python', 'java', 'c', 'c++'}
2 >>> set2 = {'c++', 'go', 'c', 'php'}
3 >>> set1.intersection(set2)
4 {'c', 'c++'}
5 >>> set1
6 {'java', 'c', 'c++', 'python'}
1 #set1发生改变
2 >>> set1 = {'python', 'java', 'c', 'c++'}
3 >>> set2 = {'c++', 'go', 'c', 'php'}
4 >>> set1.intersection_update(set2)
5 >>> set1
6 {'c', 'c++'}
7.isdisjoint(self, *args, **kwargs)
判断两个集合的交集是不是空集，如果是空集返回true
1 >>> set1 = {'python', 'java', 'c', 'c++'}
2 >>> set2 = {'c++', 'go', 'c', 'php'}
3 >>> set1.isdisjoint(set2)
4 false
5 >>> set2 = {'go', 'php'}
6 >>> set1.isdisjoint(set2)
7 true
8.issubset(self, *args, **kwargs) 与 issuperset(self, *args, **kwargs)
set1.issubset(set2)，判断set1是不是set2 的子集，如果是子集，则返回true
set1.issuperset（set2），判断set1是不是set2的父集（即set2是不是set1的子集），如果是父集，则返回true
1 >>> set2 = {'python', 'java', 'c', 'c++'}
2 >>> set1 = {'c++', 'c'}
3 >>> set1.issubset(set2)
4 true
5 >>> set1 = {'c++', 'c', 'go'}
6 >>> set1.issubset(set2)
7 false
1 >>> set1 = {'python', 'java', 'c', 'c++'}
2 >>> set2 = {'c++', 'c'}
3 >>> set1.issuperset(set2)
4 true
5 >>> set2 = {'c++', 'c', 'go'}
6 >>> set1.issuperset(set2)
7 false
9.symmetric_difference(self, *args, **kwargs) 与 symmetric_difference_update(self, *args, **kwargs)
求两个集合交叉补集，symmetric_difference方法不修改set1，返回一个交叉补集的字典副本；而symmetric_difference_update方法直接修改set1，等于交叉补集
1 >>> set1 = {'python', 'java', 'c', 'c++'}
2 >>> set2 = {'php', 'go', 'c', 'c++'}
3 >>> set1.symmetric_difference(set2)
4 {'php', 'python', 'java', 'go'}
5 >>> set1
6 {'java', 'c', 'c++', 'python'}
7 >>> set1.symmetric_difference_update(set2)
8 >>> set1
9 {'python', 'php', 'java', 'go'}
下一篇： Python：黑板课爬虫闯关第五关