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

view code

　　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'

view code

 

　　　　　　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'

view code

　　　　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 []

view code

　　　　　　前面的切片我们取到的是索引区间中的所有元素，因为我们忽略了另一个参数（即步长）。默认情况下，步长的值为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']

view code

 　　　　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')

view code

　　　　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

view code

　　　　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

view code

　　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.字符串的其他方法

字符串方法	说明
capitalize(self)	返回字符串的副本，但将第一个字符大写
casefold(self)	返回经过标准化后的字符串，类似于转换为小写
encode(self, encoding='utf-8', errors='strict')	返回使用编码的编码解码器对s进行编码。缺省编码是utf-8。可以设置错误来设置不同的错误。
expandtabs(self, tabsize=8)	返回一个字符串的副本，其中所有的制表符都是使用空格展开的。如果没有给定tabsize，则默认为8。
format(self, *args, **kwargs)	返回一个格式化版本的字符串
format_map(self, mapping)	使用映射替换来返回字符串的格式化版本
isalnum(self)	如果字符串中的所有字符都是字母或数字，则返回true。在字符串中至少有一个字符，否则为false
isalpha(self)	如果s中的所有字符都是字母，则返回true，在s中至少有一个字符，否则为false。
isdecimal(self)	如果s中只有十进制字符，则返回true， 否则为假。
isdigit(self)	如果s中的所有字符都是数字，则返回true 在s中至少有一个字符，否则为false
isidentifier(self)	如果s是有效标识符，则返回true
islower(self)	如果s中的所有字符都是小写的，则返回true
isnumeric(self)	如果s中只有数字字符，则返回true
isprintable(self)	如果s中的所有字符都是可打印的，则返回true
isspace(self)	如果s中的所有字符都是空白，则返回true
istitle(self)	检查字符串中位于非字母后面的字母是不是都是大写，且其他字母都是小写
isupper(self)	检查字符串所有字母是否都是大写
ljust(self, width, fillchar=none)	返回一个长度为max(len(string), width)的字符串，其开头是当前字符串的副本，末尾用fillchar指定的值填充
partition(self, sep)	在字符串中搜索sep，并返回元组（sep前面的部分，sep，sep后面的部分）
rfind(self, sub, start=none, end=none)	返回找到最后一个子串的索引，如果没有则引发异常
rindex(self, sub, start=none, end=none)	返回找到最后一个子串sub的索引，如果没有则引发异常
rjust(self, width, fillchar=none)	返回一个长度为max(len(string), width)的字符串，其开头是当前字符串的copy，末尾用fillchar指定的值填充
rpartition(self, sep)	在字符串中搜索sep，并返回元组
rsplit(self, sep=none, maxsplit=-1)	与split相同。但指定了maxsplit,将计算次数
splitlines(self, keepends=none)	返回一个列表，其中包括字符串中所有行，如果keepends为true，将包含换行符
swapcase(self)	将字符串中所有的字母的大小写反转，并返回结果
zfill(self, width)	在字符串左边填充0，长度为with

 　　　　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'}