【Python】整数（int）、小数/浮点数（float）、复数类型（complex）、字符串（String）、字节（bytes）、布尔（bool）详解

约定不等于承诺〃 2022-10-08 14:30 448阅读 0赞

### 整数（int）、小数/浮点数（float）、复数类型（complex）、字符串（String）、字节（bytes）、布尔（bool）详解 ###

*  整数类型（int）
 *   *  整数的不同进制
     *  数字分隔符
 *  小数/浮点数类型（float）
 *   *  浮点数的形式
     *  float 类型实例
 *  复数类型（Complex）
 *  字符串类型（String）
 *   *  处理字符串中的引号
     *  字符串的换行
     *  Python长字符串
     *  Python原始字符串
     *  原始字符串中的引号
 *  字节类型（bytes）
 *   *  字节串（bytes）和字符串（string）
 *  布尔类型（bool ）
 *   *  布尔类型可以当做整数来对待

# 整数类型（int） #

整数就是没有小数部分的数字，Python 中的整数包括`正整数、0 和负整数`。

有些强类型的编程语言会提供多种整数类型，每种类型的长度都不同，能容纳的整数的大小也不同，开发者要根据实际数字的大小选用不同的类型。

例如Java语言提供了 `byte(8位), short(16位), int(32位), long(64位)` 四种类型的整数，它们的长度依次递增，整数类型选择不当，有时候还会导致数值溢出。

而 Python 则不同，它的整数不分类型，或者说它只有一种类型的整数。

Python 整数的取值范围是无限的，不管多大或者多小的数字，Python 都能轻松处理。

> 当所用数值超过计算机自身的计算能力时，Python 会自动转用高精度计算（大数计算）。

请看下面的代码：

#将 78 赋值给变量 n
    n = 78
    print(n)
    print( type(n) )
    输出：78
    输出：<class 'int'>
    
    #给x赋值一个很大的整数
    x = 8888888888888888888888
    print(x)
    print( type(x) )
    输出：8888888888888888888888
    输出：<class 'int'>
    
    #给y赋值一个很小的整数
    y = -7777777777777777777777
    print(y)
    print( type(y) )
    输出：7777777777777777777777
    输出：<class 'int'>

x 是一个极大的数字，y 是一个很小的数字，Python 都能正确输出，不会发生溢出，这说明 Python 对整数的处理能力非常强大。

不管对于多大或者多小的整数，Python 只用一种类型存储，就是 `int`。

## 整数的不同进制 ##

在 Python 中，可以使用多种进制来表示整数：

1、十进制形式

*  我们平时常见的整数就是十进制形式，它由 `0~9` 共十个数字排列组合而成。
 *  注意，使用十进制形式的整数不能以 `0` 作为开头，除非这个数值本身就是 `0`。

2、二进制形式

*  由 `0` 和 `1` 两个数字组成，书写时以`0b`或`0B`开头。
 *  例如，`101` 对应十进制数是 `5`

3、八进制形式

*  八进制整数由 `0~7` 共八个数字组成，以`0o`或`0O`开头。
 *  注意，第一个符号是数字 `0`，第二个符号是大写或小写的字母 `O`。

4、十六进制形式

*  由 `0 ~ 9` 十个数字以及 `A ~ F`（或 `a ~ f`）六个字母组成，书写时以`0x`或`0X`开头

【实例】不同进制整数在 Python 中的使用：

#十六进制
    hex1 = 0x45
    hex2 = 0x4Af
    print("hex1Value: ", hex1)
    print("hex2Value: ", hex2)
    输出：hex1Value:  69
    输出：hex2Value:  1199
    
    #二进制
    bin1 = 0b101
    print('bin1Value: ', bin1)
    bin2 = 0B110
    print('bin2Value: ', bin2)
    输出：bin1Value:  5
    输出：bin2Value:  6
    
    #八进制
    oct1 = 0o26
    print('oct1Value: ', oct1)
    oct2 = 0O41
    print('oct2Value: ', oct2)
    输出：oct1Value:  22
    输出：oct2Value:  33

本例的输出结果都是十进制整数。

## 数字分隔符 ##

为了提高数字的的可读性，Python 3.x 允许使用下划线\_作为数字（包括整数和小数）的分隔符。

通常每隔三个数字添加一个下划线，类似于英文数字中的逗号。下划线不会影响数字本身的值。

【实例】使用下划线书写数字：

click = 1_301_547
    distance = 384_000_000
    print("Python教程阅读量：", click)
    print("地球和月球的距离：", distance)
    
    输出：Python教程阅读量：1301547
    输出：地球和月球的距离：384000000

# 小数/浮点数类型（float） #

在编程语言中，小数通常以浮点数的形式存储。

浮点数和定点数是相对的：

*  小数在存储过程中如果小数点发生移动，就称为浮点数；
 *  如果小数点不动，就称为定点数。

> 小数在内存中是如何存储的，揭秘诺贝尔奖级别的设计（长篇神文）

## 浮点数的形式 ##

1、十进制形式

这种就是我们平时看到的小数形式，`例如： 34.6、346.0、0.346`。

书写小数时必须包含一个小数点，否则会被 Python 当作整数处理。

2、指数形式

Python 小数的指数形式的写法为：

`aEn 或 aen`

*  a 为尾数部分，是一个十进制数；
 *  n 为指数部分，是一个十进制整数；
 *  E或e是固定的字符，用于分割尾数部分和指数部分。

整个表达式等价于  a × 1 0 n a × 10^n a×10n。

指数形式的小数举例：

*   2.1 E 5 2.1E5 2.1E5 =  2.1 × 1 0 5 2.1×10^5 2.1×105，其中 2.1 是尾数，5 是指数。
 *   3.7 E − 2 3.7E-2 3.7E−2 =  3.7 × 1 0 − 2 3.7×10^-2 3.7×10−2，其中 3.7 是尾数，-2 是指数。
 *   0.5 E 7 0.5E7 0.5E7 =  0.5 × 1 0 7 0.5×10^7 0.5×107，其中 0.5 是尾数，7 是指数。

注意，只要写成指数形式就是小数，即使它的最终值看起来像一个整数。

`例如`：  14 E 3 14E3 14E3 等价于 14000，但  14 E 3 14E3 14E3 是一个小数。

## float 类型实例 ##

Python 只有一种小数类型，就是 float。

Java语言有两种小数类型，分别是 float 和 double：

float 能容纳的小数范围比较小，double 能容纳的小数范围比较大。

【实例】小数在 Python 中的使用：

f1 = 12.5
    print("f1Value: ", f1)
    print("f1Type: ", type(f1))
    输出：f1Value:  12.5
    输出：f1Type:  <class 'float'>
    
    f2 = 0.34557808421257003
    print("f2Value: ", f2)
    print("f2Type: ", type(f2))
    输出：f2Value:  0.34557808421257
    输出：f2Type:  <class 'float'>
    
    f3 = 0.0000000000000000000000000847
    print("f3Value: ", f3)
    print("f3Type: ", type(f3))
    输出：f3Value:  8.47e-26
    输出：f3Type:  <class 'float'>
    
    f4 = 345679745132456787324523453.45006
    print("f4Value: ", f4)
    print("f4Type: ", type(f4))
    输出：f4Value:  3.456797451324568e+26
    输出：f4Type:  <class 'float'>
    
    f5 = 12e4
    print("f5Value: ", f5)
    print("f5Type: ", type(f5))
    输出：f5Value:  120000.0
    输出：f5Type:  <class 'float'>
    
    f6 = 12.3 * 0.1
    print("f6Value: ", f6)
    print("f6Type: ", type(f6))
    输出：f6Value:  1.2300000000000002
    输出：f6Type:  <class 'float'>

从运行结果可以看出，Python 能容纳极小和极大的浮点数。

print 在输出浮点数时，会根据浮点数的长度和大小适当的舍去一部分数字，或者采用科学计数法。

f5 的值是 120000，但是它依然是小数类型，而不是整数类型。

让人奇怪的是 f6， 12.3 ∗ 0.1 12.3\*0.1 12.3∗0.1 的计算结果很明显是  1.23 1.23 1.23，但是 print 的输出却不精确。

这是因为小数在内存中是以二进制形式存储的，小数点后面的部分在转换成二进制时很有可能是一串无限循环的数字，无论如何都不能精确表示，所以小数的计算结果一般都是不精确的。

# 复数类型（Complex） #

复数（Complex）是 Python 的内置类型，直接书写即可。

换句话说，Python 语言本身就支持复数，而不依赖于标准库或者第三方库。

复数由 实部（real） 和 虚部（imag） 构成，在 Python 中，复数的虚部以`j`或者`J`作为后缀，具体格式为：

a + bj

a 表示实部，b 表示虚部。

【实例】Python 复数的使用：

c1 = 12 + 0.2j
    print("c1Value: ", c1)
    print("c1Type", type(c1))
    输出：c1Value:  (12+0.2j)
    输出：c1Type <class 'complex'>
    
    c2 = 6 - 1.2j
    print("c2Value: ", c2)
    输出：c2Value:  (6-1.2j)
    
    #对复数进行简单计算
    print("c1+c2: ", c1+c2)
    print("c1*c2: ", c1*c2)
    输出：c1+c2:  (18-1j)
    输出：c1*c2:  (72.24-13.2j)

可以发现，复数在 Python 内部的类型是 complex，Python 默认支持对复数的简单计算。

# 字符串类型（String） #

若干个字符的集合就是一个字符串（String）。

Python 中的字符串必须由双引号`" "`或者单引号`' '`包围，具体格式为：

"字符串内容"
    '字符串内容'

字符串的内容可以包含字母、标点、特殊符号、中文、日文等全世界的所有文字。

Python 字符串中的双引号和单引号没有任何区别。

而有些编程语言的双引号字符串可以解析变量，单引号字符串一律原样输出，例如 `PHP` 和 `JavaScript`。

## 处理字符串中的引号 ##

当字符串内容中出现引号时，我们需要进行特殊处理，否则 Python 会解析出错，例如：

'I'm a great coder!'

由于上面字符串中包含了单引号，此时 Python 会将字符串中的单引号与第一个单引号配对，这样就会把’I’当成字符串，而后面的m a great coder!'就变成了多余的内容，从而导致语法错误。

对于这种情况，我们有两种处理方案:  
1、对引号进行转义

*  在引号前面添加`反斜杠\`就可以对引号进行转义，让 Python 把它作为普通文本对待，例如：

str1 = 'I\'m a great coder!'
    str2 = "引文双引号是\"，中文双引号是“"
    print(str1)
    print(str2)
    输出：I'm a great coder!
    输出：引文双引号是"，中文双引号是“

2、 使用不同的引号包围字符串

*  如果字符串内容中出现了单引号，那么我们可以使用双引号包围字符串，反之亦然。例如：

str1 = "I'm a great coder!"  #使用双引号包围含有单引号的字符串
    str2 = '引文双引号是"，中文双引号是“'  #使用单引号包围含有双引号的字符串
    print(str1)
    print(str2)

运行结果和上面相同

## 字符串的换行 ##

Python 不是格式自由的语言，它对程序的换行、缩进都有严格的语法要求。要想换行书写一个比较长的字符串，必须在行尾添加`反斜杠\`，请看下面的例子：

s2 = 'It took me six months to write this Python tutorial. \
        Please give me more support. \
        I will keep it updated.'

上面 s2 字符串的比较长，所以使用了`转义字符\`对字符串内容进行了换行，这样就可以把一个长字符串写成多行。

另外，Python 也支持表达式的换行，例如：

num = 20 + 3 / 4 + \
        2 * 3
    print(num)

## Python长字符串 ##

在《Python注释》一节中我们提到，使用三个单引号或者双引号可以对多行内容进行注释，这其实是 Python 长字符串的写法。所谓长字符串，就是可以直接换行（不用加`反斜杠\`）书写的字符串。

Python 长字符串由三个双引号`"""`或者三个单引号`'''`包围，语法格式如下：

"""长字符串内容"""
    '''长字符串内容'''

在长字符串中放置单引号或者双引号不会导致解析错误。

如果长字符串没有赋值给任何变量，那么这个长字符串就不会起到任何作用，和一段普通的文本无异，相当于被注释掉了。

> 注意，此时 Python 解释器并不会忽略长字符串，也会按照语法解析，只是长字符串起不到实际作用而已。

当程序中有大段文本内容需要定义成字符串时，优先推荐使用长字符串形式，因为这种形式非常强大，可以在字符串中放置任何内容，包括单引号和双引号。

【实例】将长字符串赋值给变量：

longstr = '''It took me 6 months to write this Python tutorial.
    Please give me a to 'thumb' to keep it updated.
    The Python tutorial is available at http://c.biancheng.net/python/.'''
    print(longstr)

长字符串中的换行、空格、缩进等空白符都会原样输出，所以你不能写成下面的样子：

longstr = '''
        It took me 6 months to write this Python tutorial.
        Please give me a to 'thumb' to keep it updated.
        The Python tutorial is available at http://c.biancheng.net/python/.
    '''
    print(longstr)

虽然这样写格式优美，但是输出结果将变成：

It took me 6 months to write this Python tutorial.
        Please give me a to 'thumb' to keep it updated.
        The Python tutorial is available at http://c.biancheng.net/python/.

字符串内容前后多出了两个空行，并且每一行的前面会多出四个空格。

## Python原始字符串 ##

Python 字符串中的`反斜杠\`有着特殊的作用，就是转义字符，例如上面提到的`\'`和`\"`，我们将在《Python转义字符》一节中详细讲解，这里大家先简单了解。

转义字符有时候会带来一些麻烦，例如我要表示一个包含 Windows 路径`D:\Program Files\Python 3.8\python.exe`这样的字符串，在 Python 程序中直接这样写肯定是不行的，不管是普通字符串还是长字符串。

因为`\`的特殊性，我们需要对字符串中的每个`\`都进行转义，也就是写成`D:\\Program Files\\Python 3.8\\python.exe`这种形式才行。

这种写法需要特别谨慎，稍有疏忽就会出错。为了解决转义字符的问题，Python 支持原始字符串。

在原始字符串中，`\`不会被当作转义字符，所有的内容都保持“原汁原味”的样子。

在普通字符串或者长字符串的开头加上`r`前缀，就变成了原始字符串，具体格式为：

str1 = r'原始字符串内容'
    str2 = r"""原始字符串内容"""

将上面的 Windows 路径改写成原始字符串的形式：

rstr = r'D:\Program Files\Python 3.8\python.exe'
    print(rstr)

## 原始字符串中的引号 ##

如果普通格式的原始字符串中出现引号，程序同样需要对引号进行转义，否则 Python 照样无法对字符串的引号精确配对；

但是和普通字符串不同的是，此时用于转义的反斜杠会变成字符串内容的一部分。

请看下面的代码：

str1 = r'I\'m a great coder!'
    print(str1)
    
    输出：I\'m a great coder!

需要注意的是，Python 原始字符串中的反斜杠仍然会对引号进行转义，因此原始字符串的结尾处不能是反斜杠，否则字符串结尾处的引号会被转义，导致字符串不能正确结束。

在 Python 中有两种方式解决这个问题：

*  一种方式是改用长字符串的写法，不要使用原始字符串；
 *  另一种方式是单独书写反斜杠，这是接下来要重点说明的。

例如想表示`D:\Program Files\Python 3.8\`，可以这样写：

str1 = r'D:\Program Files\Python 3.8' '\\'
    print(str1)
    
    输出：D:\Program Files\Python 3.8\

我们先写了一个原始字符串`r'D:\Program Files\Python 3.8'`，紧接着又使用`'\\'`写了一个包含转义字符的普通字符串，Python 会自动将这两个字符串拼接在一起

# 字节类型（bytes） #

Python bytes 类型用来表示一个字节串。`“字节串“`不是编程术语，是我自己`“捏造”`的一个词，用来和字符串相呼应。

> bytes 是 Python 3.x 新增的类型，在 Python 2.x 中是不存在的。

## 字节串（bytes）和字符串（string） ##

字节串（bytes）和字符串（string）的对比：

*  字符串由若干个字符组成，以字符为单位进行操作；字节串由若干个字节组成，以字节为单位进行操作。
 *  字节串和字符串除了操作的数据单元不同之外，它们支持的所有方法都基本相同。
 *  字节串和字符串都是不可变序列，不能随意增加和删除数据。

bytes 只负责以字节序列的形式（二进制形式）来存储数据，至于这些数据到底表示什么内容（字符串、数字、图片、音频等），完全由程序的解析方式决定。

如果采用合适的字符编码方式（字符集），字节串可以恢复成字符串；反之亦然，字符串也可以转换成字节串。

说白了，bytes 只是简单地记录内存中的原始数据，至于如何使用这些数据，bytes 并不在意，你想怎么使用就怎么使用，bytes 并不约束你的行为。

bytes 类型的数据非常适合在互联网上传输，可以用于网络通信编程；bytes 也可以用来存储图片、音频、视频等二进制格式的文件。

字符串和 bytes 存在着千丝万缕的联系，我们可以通过字符串来创建 bytes 对象，或者说将字符串转换成 bytes 对象。

有以下三种方法可以达到这个目的：

*  如果字符串的内容都是 ASCII 字符，那么直接在字符串前面添加`b前缀`就可以转换成 bytes。
 *  bytes 是一个类，调用它的构造方法，也就是 `bytes()`，可以将字符串按照指定的字符集转换成 bytes；如果不指定字符集，那么默认采用 UTF-8。
 *  字符串本身有一个 `encode()` 方法，该方法专门用来将字符串按照指定的字符集转换成对应的字节串；如果不指定字符集，那么默认采用 UTF-8。

【实例】使用不同方式创建 bytes 对象：

#通过构造函数创建空 bytes
    b1 = bytes()
    #通过空字符串创建空 bytes
    b2 = b''
    
    #通过b前缀将字符串转换成 bytes
    b3 = b'hello world'
    print("b3: ", b3)
    print(b3[3])
    print(b3[6:11])
    输出：b3:  b'hello world'
    输出：112
    输出：b'world'
    
    #为 bytes() 方法指定字符集
    b4 = bytes('类型及用法', encoding='UTF-8')
    print("b4: ", b4)
    输出：b4:  b'C\xe8\xaf\xad\xe8\xa8\x80\xe4\xb8\xad\xe6\x96\x87\xe7\xbd\x918\xe5\xb2\x81\xe4\xba\x86'
    
    #通过 encode() 方法将字符串转换成 bytes
    b5 = "类型及用法".encode('UTF-8')
    print("b5: ", b5)
    输出：b5:  b'C\xe8\xaf\xad\xe8\xa8\x80\xe4\xb8\xad\xe6\x96\x87\xe7\xbd\x918\xe5\xb2\x81\xe4\xba\x86'

从运行结果可以发现，对于非 ASCII 字符，print 输出的是它的字符编码值（十六进制形式），而不是字符本身。

非 ASCII 字符一般占用两个字节以上的内存，而 bytes 是按照单个字节来处理数据的，所以不能一次处理多个字节。

# 布尔类型（bool ） #

Python 提供了 bool 类型来表示真（对）或假（错）

比如常见的 5 > 3 5 > 3 5>3比较算式，这个是正确的，在程序世界里称之为真（对），Python 使用 True 来代表；

再比如 4 > 20 4 > 20 4>20比较算式，这个是错误的，在程序世界里称之为假（错），Python 使用 False 来代表。

> True 和 False 是 Python 中的关键字，当作为 Python 代码输入时，一定要注意字母的大小写，否则解释器会报错。

## 布尔类型可以当做整数来对待 ##

值得一提的是，布尔类型可以当做整数来对待，即 True 相当于整数值 1，False 相当于整数值 0。因此，下边这些运算都是可以的：

>>> False + 1
    1
    >>> True + 1
    2

注意，这里只是为了说明 `True` 和 `Flase` 对应的整型值，在实际应用中是不妥的，不要这么用。

总的来说，bool 类型就是用于代表某个事情的真（对）或假（错）