常见内置数据类型

标签(tag):

Python，数据类型，可变对象，不可变对象，可哈希对象，可迭代对象，可遍历对象

参考资料：
Python 文档：内置类型(Build-in Types)
Python 文档：数据模型 - 对象、值与类型
Python 文档：术语对照表 - 可哈希
Python 文档：属于对照表 - 可迭代对象
Python 文档：逻辑值检测
Python 文档：数字类型 - int, float, and complex
Python 文档：序列类型 - list, tuple, and range
Python 文档：字符串的方法
Python 文档：可变序列类型
Python 文档：集合类型 set 与 frozenset
Python 文档：映射类型 dict
Python 文档：运算优先级

Python的常用内置类型（Build-in Types）

参考资料：Python内置类型(Build-in Types)

在Python中，常用的类型是这些：

Python中查看数据类型的函数(function)为type()。

Python中常看该数据类型的内置方法(build-in method)的函数为dir()。

Python中查看变量内存地址的函数为：id()。

一个对象是否可变(mutable)

参考资料：Python 文档：数据模型 - 对象、值与类型

复习：来自01_Python中的变量

• 对象(object)是存储在内存(memory)某处的数据(data)。
  • 每个对象都有一个内存地址(memory address)、一个类型(type)和一个值(value)。

在Python中，一个对象被创建后，它的内存地址是永远不变的。

一些对象的值在对象被创建后是不能再更改的，这类对象被称为不可变对象(immutable objects)；
一些对象的值在被创建后任可被修改，这类对象被称为可变对象(mutable obejcts)。

一个对象是否可变，取决于该对象的类型(type)。也就是说：拥有不可变类型的对象就是不可变对象，拥有可变类型的对象就是可变对象。

哪些常见类型是可变或不可变类型呢？

常见可变类型有：列表(List)，集合(Set)，字典(Dictionary)

常见不可变类型有：数值类型(Numeric Types)、元组(Tuple)、range、字符串(String)、frozenset。

Python实例1：

>>>var = [1, 2, 3]           # 创建一个引用列表对象(list)的变量
>>>print(id(var),type(var))  # 打印该变量的内存地址和类型
2803140207104 <class 'list'>
>>>var[0] = 5                # 更改该对象的值（var没有引用新的对象）
>>>var                       # 打印该对象，对象的值已被修改
[5, 2, 3]
>>>print(id(var),type(var))  # 再次打印该对象的内存地址和类型
2803140207104 <class 'list'> # 内存地址没有改变，var引用同一个对象。

>>>var = True                  # 创建一个引用布尔对象(bool)的变量
>>>print(id(var),type(var))    # 打印该变量的内存地址和类型
140716609805160 <class 'bool'>
>>>var = False                 # 改变该变量的值
>>>print(id(var),type(var))    # 重新打印该变量的内存地址和类型
140716609805192 <class 'bool'> # 内存地址改变，var引用不同的对象

一个对象是否可哈希(hashable)

参考资料：Python 文档：术语对照表 - 可哈希

一个对象的哈希值(hash value)如果在其生命周期内绝不改变，并可以同其他对象进行比较，就被称为可哈希(hashable)。

在Python中，如果对象有__hash__()和__eq__()方法(method)，且该对象不可变，那么该对象就是可哈希的。

Python常用内置类型中：

• 可哈希的类型有：数值类型、字符串类型、range。

• 不可哈希类型有：列表类型、字典类型、可变集合类型(set)。

• 如果不可变容器的所有元素都是可哈希的，那么该不可变容器也是可哈希的。

  • 元组、frozenset

Python实例：

>>>'__hash__' in dir(5)	 
True
>>>'__eq__' in dir(5)	 
True
>>>hash(5)
5
>>># 数值类型不可变，且有用__hash__和__eq__，因此数据类型可哈希。

>>>list1 = [1, 2, 3]
>>>'__hash__' in dir(list1)
True
>>>'__eq__' in dir(list1)
True
>>>hash(list1)
Traceback (most recent call last):
  File "<pyshell#20>", line 1, in <module>
    hash(list1)
TypeError: unhashable type: 'list'
>>># list类型可变，哪怕拥有__hash__和__eq__也不可哈希。

一个对象是否可迭代(iterable)

参考资料：
Python 文档：属于对照表 - 可迭代对象

如果一个对象能够逐一返回其成员项，那么这个对象就是可迭代的(iterable)，也叫做可遍历(traversal)的。

在Python中，如果对象有__iter__()或__getitem__方法(method)，那么该对象就是可迭代的。

Python常见类型中所有的序列类型(list, tuple, str, range)、集合类型(set, frozenset)与映射类型(dict)都可迭代。

Python实例：

>>>'__iter__' in dir([1, 2, 3])
True
>>># list类型拥有可迭代。
>>>'__iter__' in dir(5)
False
>>># 数值类型不可迭代。

数值类型(Numeric Type)

数值类型是不可变类型(immutable type)，它包括布尔类型、整数、浮点数与复数。

布尔类型

参考资料：Python 文档：逻辑值检测

布尔类型只有俩个值，一个是True，另一个是False。

常见内置类型被视为False的情况：

• 被定义为假值的常量: None 和 False
• 任何数值类型的零: 0, 0.0, 0j, Decimal(0), Fraction(0, 1)
• 空的序列和多项集: '', (), [], {}, set(), range(0)

通俗来讲，非空非零即为真。

布尔运算 --- and, or, not

这些属于布尔运算(Boolean Operations)，按优先级排列:

比较运算符(Comparison Operators)

在 Python 中有八种比较运算符。 它们的优先级相同，且高于布尔运算。

比较运算可以任意串连；例如，x < y <= z 等价于 x < y and y <= z，前者的不同之处在于 y 只被求值一次。在两种情况下当 x < y 结果为假值时 z 都不会被求值，因为and为短路运算符。

此表格汇总了比较运算:

除不同的数值类型外，不同类型的对象相等比较的结果总是False。
对于某些对象类型（例如，类对象 class object），== 等价于 is 。
因此，具有不同标识的类的实例比较结果通常为不相等，除非类定义了__eq__()方法。

整数型、浮点型、复数型

参考资料：Python 文档：数字类型 - int, float, and complex

Python完全支持三种数值类型的混合运算，因此平时不必太过在意它们的类型。

在Python中，复数的虚数部分由j表示，而不是数学中常用的i。这主要是为了增加代码在不同字体下的可读性。

要从一个复数 z 中提取这两个部分，可使用 z.real 和 z.imag。

所有数字类型（复数除外）都支持下列运算（有关运算优先级，请参阅：运算符优先级）:

部分方程的完整文档：abs()，int()， float()，complex()，divmod()，pow()。

注释：

1. 也称为整数除法。 对于 int 类型的操作数，结果的类型为 int。 对于 float 类型的操作数，结果的类型为 float。
2. 不可用于复数。 而应在适当条件下使用 abs()转换为浮点数。
3. float 也接受字符串 "nan" 和附带可选前缀 "+" 或 "-" 的 "inf" 分别表示非数字 (NaN) 以及正或负无穷。
4. Python 将 pow(0, 0) 和 0 ** 0 定义为 1，这是编程语言的普遍做法。

序列类型(Sequence Type)

参考资料：Python 文档：序列类型 - list, tuple, and range

列表(list)

列表是可变序列，通常用于存放同类项目的集合。列表实现了所有通用序列操作[通用序列操作](#通用序列操作(Common Sequence Operation) )和[可变序列操作](#可变序列类型(Mutable Sequence Type))。

列表的构建方式：

• 使用一对方括号来表示空列表: []
• 使用方括号，其中的项以逗号分隔: [a], [a, b, c]
• 使用列表推导式: [x for x in iterable]
• 使用类型的构造器: list() 或 list(iterable)

列表内置方法：

sort(*, key=None, reverse=False)

此方法会对列表进行排序，只使用 < 来进行各项间比较。

key 是带有一个参数的函数，它用于从每个列表元素中提取比较键 (例如 key=str.lower)。 对应于列表中每一项的键会被计算一次，然后在整个排序过程中使用。 默认值 None 表示直接对列表项排序而不计算一个单独的键值。

reverse 如果设为 True，则每个列表元素将按反向顺序比较进行排序。

元组(tuple)

元组是不可变序列，实现了所有[通用序列操作](#通用序列操作(Common Sequence Operation) )。

元组的构建方式：

• 使用一对圆括号来表示空元组: ()
• 使用一个后缀的逗号来表示单元组: a, 或 (a,)
• 使用以逗号分隔的多个项: a, b, c or (a, b, c)
• 使用内置的 tuple(): tuple() 或 tuple(iterable)

请注意决定生成元组的其实是逗号而不是圆括号。 圆括号只是可选的，生成空元组或需要避免语法歧义的情况除外。 例如，f(a, b, c) 是在调用函数时附带三个参数，而 f((a, b, c)) 则是在调用函数时附带一个三元组。

range对象

range类型表示不可变的数字序列，通常用于在 for 循环中循环指定的次数。range 对象实现了[通用序列操作](#通用序列操作(Common Sequence Operation) )，但拼接和重复除外。

range的构造方式：

class range(stop)
class range(start, stop[, step])

注意事项

• range 构造器的参数必须为整数。
• 如果省略 step 参数，则默认为 1。 如果省略 start 参数，则默认为 0。 如果 step 为零，则会引发 ValueError。
• 如果 step 为正值，确定 range r 内容的公式为 r[i] = start + step*i 其中 i >= 0 且 r[i] < stop。
• 如果 step 为负值，确定 range 内容的公式仍然为 r[i] = start + step*i，但限制条件改为 i >= 0 且 r[i] > stop.
• 如果 r[0] 不符合值的限制条件，则该 range 对象为空。
• range 对象支持负索引，将其解读为从正索引所确定的序列的末尾开始索引。

字符串(String)

字符串是由 Unicode 码位构成的不可变序列。字符串实现了所有[通用序列操作](#通用序列操作(Common Sequence Operation) )。

str的构造方式

• 单引号: '允许包含有 "双" 引号'
• 双引号: "允许嵌入 '单' 引号"
• 三重引号: '''三重单引号''', """三重双引号"""（三重引号保留文本原始格式）
• 禁止转义字符生效：r'\n不会转义', r"\t也不会转义"等

由于不存在单独的“字符”类型，对字符串做索引操作将产生一个长度为 1 的字符串。 也就是说，对于一个非空字符串 s, s[0] == s[0:1]。

字符串常用内置方法：

参考资料：Python 文档：字符串的方法

通用序列操作(Common Sequence Operation)

大多数序列类型，包括可变类型和不可变类型都支持下表中的操作。

此表按优先级升序列出了序列操作。 在表格中，s 和 t 是具有相同类型的序列，n, i, j 和 k 是整数而 x 是任何满足 s 所规定的类型和值限制的任意对象。

in 和 not in 操作具有与比较操作相同的优先级。 + (拼接) 和 * (重复) 操作具有与对应数值运算相同的优先级，因为解析器无法判断操作数的类型

相同类型的序列也支持比较运算(Comparison Operation)。tuple 和 list 的比较是通过比较对应元素的字典顺序(lexicographically order)。 想要二者比较结果相等，则每个元素比较结果都必须相等，且两个序列长度必须相同。

注释：

2. 小于 0 的 n 值会被当作 0 来处理 (生成一个与 s 同类型的空序列)。 请注意序列 s 中的项并不会被拷贝；它们会被多次引用。例如:

lists = [[]] * 3
lists
[[], [], []]
lists[0].append(3)
lists
[[3], [3], [3]]

具体的原因在于 [[]] 是一个包含了一个空列表的单元素列表，所以 [[]] * 3 结果中的三个元素都是对这一个空列表的引用。 修改 lists 中的任何一个元素实际上都是对这一个空列表的修改。 你可以用以下方式创建以不同列表为元素的列表:

lists = [[] for i in range(3)]
lists[0].append(3)
lists[1].append(5)
lists[2].append(7)
lists
[[3], [5], [7]]

3. 如果 i 或 j 为负值，则索引顺序是相对于序列 s 的末尾: 索引号会被替换为 len(s) + i 或 len(s) + j。 但要注意 -0 仍然为 0。

4. s 从 i 到 j 的切片被定义为所有满足 i <= k < j 的索引号 k 的项组成的序列。 如果 i 或 j 大于 len(s)，则使用 len(s)。 如果 i 被省略或为 None，则使用 0。 如果 j 被省略或为 None，则使用 len(s)。 如果 i 大于等于 j，则切片为空。

5. s 从 i 到 j 步长为 k 的切片被定义为所有满足 0 <= n < (j-i)/k 的索引号 x = i + n*k 的项组成的序列。 换句话说，索引号为 i, i+k, i+2*k, i+3*k，以此类推，当达到 j 时停止 (但一定不包括 j)。 当 k 为正值时，i 和 j 会被减至不大于 len(s)。 当 k 为负值时，i 和 j 会被减至不大于 len(s) - 1。 如果 i 或 j 被省略或为 None，它们会成为“终止”值 (是哪一端的终止值则取决于 k 的符号)。 请注意，k 不可为零。 如果 k 为 None，则当作 1 处理。

6. 拼接不可变序列总是会生成新的对象。 这意味着通过重复拼接来构建序列的运行时开销将会基于序列总长度的乘方。 想要获得线性的运行时开销，你必须改用下列替代方案之一：

• 如果拼接 str 对象，你可以构建一个列表并在最后使用 str.join() 或是写入一个 io.StringIO 实例并在结束时获取它的值
• 如果拼接 bytes 对象，你可以类似地使用 bytes.join() 或 io.BytesIO，或者你也可以使用 bytearray 对象进行原地拼接。 bytearray 对象是可变的，并且具有高效的重分配机制
• 如果拼接 tuple 对象，请改为扩展 list 类
• 对于其它类型，请查看相应的文档

7. 某些序列类型 (例如 range`) 并不支持序列拼接或重复，仅支持遵循特定模式的项序列

8. 当 x 在 s 中找不到时 index 会引发 ValueError)。 不是所有对象(object)都支持传入额外参数 i 和 j。 这两个参数允许高效地搜索序列的子序列。 传入这两个额外参数大致相当于使用 s[i:j].index(x)，但是不会复制任何数据，并且返回的索引是相对于序列的开头而非切片的开头。

可变序列类型(Mutable Sequence Type)

参考资料：Python 文档：可变序列类型

以下表格中的操作是在可变序列类型上定义的。

表格中的 s 是可变序列类型的实例(instance)，t 是任意可迭代对象(iterable object)，而 x 是符合对 s 所规定类型与值限制的任何对象。

注释：

1. t 必须与它所替换的切片具有相同的长度。

2. 可选参数 i 默认为 -1，因此在默认情况下会移除并返回最后一项。

3. 当在 s 中找不到 x 时 remove() 操作会引发 ValueError。

4. 当反转大尺寸序列时 reverse() 方法会原地修改该序列以保证空间经济性。 为提醒用户此操作是通过间接影响进行的，它并不会返回反转后的序列。

5. 包括 clear() 和 copy() 是为了与不支持切片操作的可变容器 (例如 dict 和 set) 的接口保持一致。 copy() 不是 collections.abc.MutableSequence ABC 的一部分，但大多数具体的可变序列类都提供了它。

   3.3 新版功能: clear() 和 copy() 方法。

6. n 值为一个整数，或是一个实现了 __index__() 的对象。 n 值为零或负数将清空序列。 序列中的项不会被拷贝；它们会被多次引用，正如 [通用序列操作](#通用序列操作(Common Sequence Operation)) 中有关 s * n 的说明。

集合类型(Set Type)

参考资料：Python 文档：集合类型 set 与 frozenset

set type 对象是由具有唯一性的可哈希(hashable)对象所组成的无序多项集，set type的所有元素必须可哈希。由于集合类型是无序的，它并不记录元素位置或插入顺序，因此集合类型不支持索引、切片或其他序列类的操作。

set的内容可以使用 add() 和 remove() 来改变。

set和frozenset的构建方式:

• 使用花括号内以逗号分隔元素的方式: {'jack', 'sjoerd'}
• 使用集合推导式: {c for c in 'abracadabra' if c not in 'abc'}
• 使用类型构造器: set(), set('foobar'), set(['a', 'b', 'foo'])

frozenset可通过构造函数frozenset()来创建：

class set([iterable])
class frozenset([iterable])

上述俩种构建器输入一个可迭代对象(iterable))返回一个新的 set 或 frozenset 对象。 集合的元素必须为可哈希的。要表示由集合对象构成的集合，所有的内层集合必须为 frozenset对象。 如果未指定可迭代对象，则将返回一个新的空集合。

可用于set和frozenset的操作

下表中 s 代表多项集(collection)，x 是任何满足 s 所规定的类型和值限制的任意对象，set代表集合，other代表另一集合。

注意：

• union()、intersection()、difference()、symmetric_difference()、issubset()和issuperset()方法可以接受任何可迭代对象作为参数。
  而基于运算符的对应方法则要求参数为集合对象。

• 混合了set实例与frozenset的二进制位运算将返回与第一个操作数相同的类型。例如: frozenset('ab') | set('bc') 将返回frozenset的实例。

可用于set但不可用于frozenset的操作

下表中 set代表集合，other代表另一集合。elem代表满足set所有要求的元素。

注意：

• update()，intersection_update()，difference_update()和symmetric_difference_update()方法将接受任意可迭代对象作为参数。
• __contains__(), remove() 和 discard() 方法的 elem 参数可能是一个 set。 为支持对一个等价的 frozenset 进行搜索，会根据 elem 临时创建一个该类型对象。

映射类型(dict)

参考资料：Python 文档：映射类型 dict

映射(mapping)类型对象会将可哈希值映射到任意对象。 映射属于可变对象。字典是内置的映射类型。

字典由键值对构成。字典的键(key)可以是任何可哈希值，而值可以是任意对象。

字典的构造方式:

• 使用花括号内以逗号分隔 键: 值 对的方式: {'jack': 4098, 'sjoerd': 4127} or {4098: 'jack', 4127: 'sjoerd'}
• 使用字典推导式: {}, {x: x ** 2 for x in range(10)}
• 使用类型构造器: dict(), dict([('foo', 100), ('bar', 200)]), dict(foo=100, bar=200)

如果没有给出位置参数，将创建一个空字典。 如果给出一个位置参数并且其属于映射对象，将创建一个具有与映射对象相同键值对的字典。 否则的话，位置参数必须为一个 iterable对象。 该可迭代对象中的每一项本身必须为一个刚好包含两个元素的可迭代对象。 每一项中的第一个对象将成为新字典的一个键，第二个对象将成为其对应的值。 如果一个键出现一次以上，该键的最后一个值将成为其在新字典中对应的值。

如果给出了关键字参数，则关键字参数及其值会被加入到基于位置参数创建的字典。 如果要加入的键已存在，来自关键字参数的值将替代来自位置参数的值。

可用于字典(dict)的操作

d代表一个字典

本栏目推荐文章
• Jmeter 如何连接mysql数据库？
• 函数的参数类型
• SQL Server 检测是不是数字型数据的两种方法
• Maven常见问题与原理技巧
• 如何通过Navicat把MySQL远程数据库导入到本地数据库
• 和利时MACS6通过dat文件实现任意时间范围与测点的历史数据提取与科研分析
• 深入理解spring框架：剖析多线程模式下数据库连接
• 数据可视化是如何帮助大型企业提高效率的？
• redis 数据库
• openpyxl模块--------------------------------重复数据