Python 数据类型

2018-11-05 08:24:20来源:博客园 阅读 ()

新老客户大回馈,云服务器低至5折

一:数字

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

 

 

    

 

 

 

 

      

 

 

 

    

 

    

标签:

版权申明:本站文章部分自网络,如有侵权,请联系:west999com@outlook.com
特别注意:本站所有转载文章言论不代表本站观点,本站所提供的摄影照片,插画,设计作品,如需使用,请与原作者联系,版权归原作者所有

上一篇:Python全栈学习_day004作业

下一篇:python 输入一个整数,判断其是否既是3的倍数,又是5的倍数