数据类型(元组,集合,字典,None)

最新推荐文章于 2021-12-27 23:19:00 发布

白夜行人

最新推荐文章于 2021-12-27 23:19:00 发布

阅读量504

点赞数

文章标签： python 数据

本文链接：https://blog.csdn.net/github_37646502/article/details/56844329

版权

接上一篇的元组

同时赋多个值

以下是一种很酷的编程捷径：在 Python 中，可使用元组来一次赋多值。

>>> v = ('a', 2, True)
>>> (x, y, z) = v       
>>> x
'a'
>>> y
2
>>> z
True

内建的 range() 函数构造了一个整数序列。（从技术上来说， range() 函数返回的既不是列表也不是元组，而是一个迭代器，但稍后您将学到它们的区别。）

>>> (MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY) = range(7)  ①
>>> MONDAY                                                                       ②
0
>>> TUESDAY
1
>>> SUNDAY
6

集合

集合set 是装有独特值的无序“袋子”。一个简单的集合可以包含任何数据类型的值。如果有两个集合，则可以执行像联合、交集以及集合求差等标准集合运算。

集合的创建

用{}

>>> a_set = {1}     ①
>>> a_set
{1}
>>> type(a_set)     ②
<class 'set'>
>>> a_set = {1, 2}  ③
>>> a_set
{1, 2}

列表为基础创建集合。

用set（）函数。值得注意的是，不能使用两个花括号来创建空集合，只能
>>> a_set = set()。但该操作实际创建一个空字典，而不是一个空集合。

>>> a_list = ['a', 'b', 'mpilgrim', True, False, 42]
>>> a_set = set(a_list)                           ①
>>> a_set                                         ②
{'a', False, 'b', True, 'mpilgrim', 42}

添加参数

有两种方法可向现有集合中添加值： add() 方法和 update() 方法。

add() 方法接受单个可以是任何数据类型的参数，并将该值添加到集合之中。
a_set.add(4)
update() 方法仅接受一个集合作为参数，并将其所有成员添加到初始列表中。其行为方式就像是对参数集合中的每个成员调用 add()
方法。由于集合不能包含重复的值，因此重复的值将会被忽略。
a_set.update({3, 6, 9}, {1, 2, 3, 5, 8, 13})

删除元素

有三种方法可以用来从集合中删除某个值。

前两种，discard() 和 remove() 有细微的差异。
区别在这里：如果该值不在集合中，remove() 方法引发一个 KeyError 例外。

 >>> a_set
{1, 3, 36, 6, 45, 15, 21, 28}
>>> a_set.remove(21)                         ③
>>> a_set
{1, 3, 36, 6, 45, 15, 28}

就像列表，集合也有个 pop() 方法。
pop() 方法从集合中删除某个值，并返回该值。然而，由于集合是无序的，并没有“最后一个”值的概念，因此无法控制删除的是哪一个值。它基本上是随机的。
clear() 方法删除集合中所有的值，留下一个空集合。它等价于
a_set = set()，该语句创建一个新的空集合，并用之覆盖 a_set 变量的之前的值。

集合运算

>>> a_set = {2, 4, 5, 9, 12, 21, 30, 51, 76, 127, 195}
>>> 30 in a_set                                                     ①
True
>>> 31 in a_set
False
>>> b_set = {1, 2, 3, 5, 6, 8, 9, 12, 15, 17, 18, 21}
>>> a_set.union(b_set)                                              ②
{1, 2, 195, 4, 5, 6, 8, 12, 76, 15, 17, 18, 3, 21, 30, 51, 9, 127}
>>> a_set.intersection(b_set)                                       ③
{9, 2, 12, 5, 21}
>>> a_set.difference(b_set)                                         ④
{195, 4, 76, 51, 30, 127}
>>> a_set.symmetric_difference(b_set)                               ⑤
{1, 3, 4, 6, 8, 76, 15, 17, 18, 195, 127, 30, 51}

in 运算符.要检测某值是否是集合的成员，可使用 in 运算符。其工作原理和列表的一样。
交，union() 方法返回一个新集合，其中装着在两个集合中出现的元素。
并，intersection() 方法返回一个新集合，其中装着同时在两个集合中出现的所有元素。
补， difference() 方法返回的新集合中，装着所有在 a_set 出现但未在 b_set 中的元素。
最后，有几个您可能会问到的问题。

>>> a_set = {1, 2, 3}
>>> b_set = {1, 2, 3, 4}
>>> a_set.issubset(b_set)    ①
True
>>> b_set.issuperset(a_set)  ②
True
>>> a_set.add(5)             ③
>>> a_set.issubset(b_set)
False
>>> b_set.issuperset(a_set)
False

a_set 是 b_set 的子集 — 所有 a_set 的成员均为 b_set 的成员。
同样的问题反过来说， b_set 是 a_set 的超集，因为 a_set 的所有成员均为 b_set 的成员。
一旦向 a_set 添加一个未在 b_set 中出现的值，两项测试均返回 False 。

字典

字典是键值对的无序集合。向字典添加一个键的同时，必须为该键增添一个值。（之后可随时修改该值。） Python 的字典为通过键获取值进行了优化，而不是反过来。

Python 中的字典与 Perl 5 中的 hash [散列]类似。在 Perl 5 中，散列存储的变量总是以一个 % 符开头。在 Python 中，变量可以随意命名，而 Python 内部跟踪其数据类型。

创建

>>> a_dict = {'server': 'db.diveintopython3.org', 'database': 'mysql'}

修改

>>> a_dict
{'server': 'db.diveintopython3.org', 'database': 'blog'}
>>> a_dict['user'] = 'mark'

字典键是区分大小写的；
在字典中不允许有重复的键，对现有的键赋值将会覆盖旧值。

混合值字典

字典的值可以是任何数据类型，甚至是其它的字典。
字典的键要严格得多（键是前面的）
1.不允许一个键对应多个值，
2.键必须是可哈希的。
在同一字典中也可混合、匹配使用不同数据类型的键。

SUFFIXES = {1000: ['KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'],
            1024: ['KiB', 'MiB', 'GiB', 'TiB', 'PiB', 'EiB', 'ZiB', 'YiB']}

让我们在交互式 shell 中剖析一下：

>>> SUFFIXES = {1000: ['KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'],
...             1024: ['KiB', 'MiB', 'GiB', 'TiB', 'PiB', 'EiB', 'ZiB', 'YiB']}
>>> len(SUFFIXES)      ①
2
>>> 1000 in SUFFIXES   ②
True
>>> SUFFIXES[1000]     ③
['KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB']
>>> SUFFIXES[1024]     ④
['KiB', 'MiB', 'GiB', 'TiB', 'PiB', 'EiB', 'ZiB', 'YiB']
>>> SUFFIXES[1000][3]  ⑤
'TB'

类似列表和集合，len() 函数将返回字典中键的数量。
而且像列表和集合一样，可使用 in 运算符以测试某个特定的键是否在字典中。
1000 是字典 SUFFIXES 的一个键；其值为一个 8 元素列表（确切地说，是 8 个字符串）。
同样， 1024 是字典 SUFFIXES 的键；其值也是一个 8 元素列表。
由于 SUFFIXES[1000] 是列表，可以通过它们的 0 基点索引来获取列表中的单个元素。

>>> is_it_true({})             
no, it's false

在布尔类型上下文环境中，空字典为假值。

None

None 是 Python 的一个特殊常量。它是一个空值。None 与 False 不同。None 不是 0 。None 不是空字符串。将 None 与任何非 None 的东西进行比较将总是返回 False 。

None 是唯一的空值。它有着自己的数据类型（NoneType）。可将 None 赋值给任何变量，但不能创建其它 NoneType 对象。所有值为 None 变量是相等的。

>>> type(None)
<class 'NoneType'>
>>> None == False
False
>>> None == 0
False

在布尔类型上下文环境中， None 为假值，而 not None 为真值。

>>> def is_it_true(anything):
...   if anything:
...     print("yes, it's true")
...   else:
...     print("no, it's false")
...
>>> is_it_true(None)
no, it's false
>>> is_it_true(not None)
yes, it's true