数据类型

Created: November-22, 2018

内置类型

布尔

bool：True 或 False 的布尔值。像 and，or，not 这样的逻辑运算可以在布尔值上执行。

x or y    # if x is False then y otherwise x 
x and y   # if x is False then x otherwise y
not x     # if x is True then False, otherwise True

在 Python 2.x 和 Python 3.x 中，布尔值也是一个 int。bool 类型是 int 类型的子类，True 和 False 是它唯一的实例：

issubclass(bool, int) # True

isinstance(True, bool) # True
isinstance(False, bool) # True

如果在算术运算中使用布尔值，则它们的整数值（1 和 0 用于 True 和 False）将用于返回整数结果：

True + False == 1 # 1 + 0 == 1
True * True  == 1 # 1 * 1 == 1

数字

int：整数
```
a = 2
b = 100
c = 123456789
d = 38563846326424324
```
Python 中的整数具有任意大小。

注意：在旧版本的 Python 中，可以使用 long 类型，这与 int 不同。这两个已经统一了。
float：浮点数; 精度取决于实现和系统架构，对于 CPython，float 数据类型对应于 C double。
```
a = 2.0
b = 100.e0
c = 123456789.e1
```
complex：复数
```
a = 2 + 1j
b = 100 + 10j
```

当任何操作数是复数时，<，<=，> 和 >= 运算符将引发 TypeError 异常。

字符串

Python 3.x >= 3.0

str：一个 unicode 字符串。'hello'的类型
bytes：一个字节字符串。b'hello'的类型

Python 2.x <= 2.7

str：一个字节字符串。'hello'的类型
bytes：str 的同义词
unicode：一个 unicode 字符串。u'hello'的类型

序列和集合

Python 区分有序序列和无序集合（例如 set 和 dict）。

字符串（str，bytes，unicode）是序列
reversed：具有 reversed 功能的 str 的逆序
```
a = reversed('hello')
```
tuple：任何类型的 n 值的有序集合（n >= 0）。
```
a = (1, 2, 3)
b = ('a', 1, 'python', (1, 2))
b[2] = 'something else' # returns a TypeError
```
支持索引; 不可改变的; 如果其所有成员都可以清洗，则可以清洗

list：n 值的有序集合（n >= 0）

a = [1, 2, 3]
b = ['a', 1, 'python', (1, 2), [1, 2]]
b[2] = 'something else' # allowed

不可洗; 可变的。

set：无序的唯一值集合。物品必须是可清洗的。
```
a = {1, 2, 'a'}
```

dict：一组无序的唯一键值对; 键必须是可以清洗的。

a = {1: 'one',
     2: 'two'}

b = {'a': [1, 2, 3],
     'b': 'a string'}

如果一个对象具有一个在其生命周期内永远不会改变的哈希值（它需要一个 __hash__() 方法），并且可以与其他对象进行比较（它需要一个 __eq__() 方法），则该对象是可清除的。比较相等性的 Hashable 对象必须具有相同的哈希值。

内置常量

结合内置数据类型，内置命名空间中有少量内置常量：

True：内置式 bool 的真正价值
False：内置类型 bool 的错误值
None：用于表示某个值不存在的单例对象。
Ellipsis 或 ...：在 Python3 +核心中使用，在 Python2.7 +中作为数组表示法的一部分使用有限。numpy 和相关软件包将其用作数组中的包含所有内容引用。
NotImplemented：用于向 Python 指示特殊方法不支持特定参数的单例，如果可用，Python 将尝试替代方法。

a = None # No value will be assigned. Any valid datatype can be assigned later

Python 3.x >= 3.0

None 没有任何自然顺序。不再支持使用订购比较运算符（<，<=，>=，>）并且将提升 TypeError。

Python 2.x <= 2.7

None 总是小于任何数字（None < -32 评估为 True）。

测试变量的类型

在 python 中，我们可以使用内置函数 type 检查对象的数据类型。

a = '123'
print(type(a))
# Out: <class 'str'>
b = 123
print(type(b))
# Out: <class 'int'>

在条件语句中，可以使用 isinstance 测试数据类型。但是，通常不鼓励依赖变量的类型。

i = 7
if isinstance(i, int):
    i += 1
elif isinstance(i, str):
    i = int(i)
    i += 1

有关 type() 和 isinstance() 之间差异的信息，请参阅： Python 中 isinstance 和 type 之间的差异

要测试是否有什么东西是 NoneType：

x = None
if x is None:
    print('Not a surprise, I just defined x as None.')

在数据类型之间转换

你可以执行显式数据类型转换。

例如，‘123’是 str 类型，可以使用 int 函数将其转换为整数。

a = '123'
b = int(a)

可以使用 float 函数从浮点字符串（例如'123.456’）转换。

a = '123.456'
b = float(a)
c = int(a)    # ValueError: invalid literal for int() with base 10: '123.456'
d = int(b)    # 123

你还可以转换序列或集合类型

a = 'hello'
list(a)  # ['h', 'e', 'l', 'l', 'o']
set(a)   # {'o', 'e', 'l', 'h'}
tuple(a) # ('h', 'e', 'l', 'l', 'o')

文字定义的显式字符串类型

在引号前面有一个字母标签，你可以知道要定义的字符串类型。

b'foo bar'：Python 3 中的 bytes，Python 2 中的 str
u'foo bar'：Python 3 中的 str，Python 2 中的 unicode
'foo bar'：结果 str
r'foo bar'：结果所谓的原始字符串，其中不需要转义特殊字符，所有内容都是在你输入时逐字记录的

normal  = 'foo\nbar'   # foo
                       # bar
escaped = 'foo\\nbar'  # foo\nbar   
raw     = r'foo\nbar'  # foo\nbar

可变和不可变数据类型

如果可以更改对象，则称为 mutable 。例如，当你将列表传递给某个函数时，可以更改列表：

def f(m):
    m.append(3)  # adds a number to the list. This is a mutation.

x = [1, 2]
f(x)
x == [1, 2]  # False now, since an item was added to the list

如果无法以任何方式更改对象，则该对象称为不可变。例如，整数是不可变的，因为没有办法改变它们：

def bar():
    x = (1, 2)
    g(x)
    x == (1, 2)  # Will always be True, since no function can change the object (1, 2)

请注意，变量本身是可变的，因此我们可以重新分配变量 x，但这不会改变 x 之前指向的对象。它只让 x 指向一个新对象。

实例可变的数据类型称为可变数据类型，类似于不可变对象和数据类型。

不可变数据类型的示例：

int，long，float，complex
str
bytes
tuple
frozenset

可变数据类型的示例：

bytearray
list
set
dict