1.5 Python基础-数据类型

一、内置数据类型

Python 3 中常用的内置数据类型（待完善）如下所示：

注意：

1. 布尔值属于整数的子类型，所以bool类型包含于int类型中。
2. 整数具有无限的精度。在Python 3 中取消了长整数long类型，Python 2 中有long类型（长整数数据末尾需要加字母“L”，否则会出错。但从Python 2.2 开始，如果整数发生溢出，将自动转换为长整数类型，所以，没有在长整数数据末尾加字母“L”也不会出错）。
3. 浮点数float使用 C 中的 double 来实现，所以float类型具有C中double类型的精度。
4. 字符串str是由 Unicode 码构成的不可变文本序列类型。

可变类型：list(列表)、set(集合)、dict(字典)；
不可变数类型：int(整数)、float(浮点数)、complex(复数)、str(字符串)、tuple(元组)。

二、类型转换

常用的类型转换

函数	说明
int(x [, base])	将X转换为整数。可选参数base可以指定，把被转换的对象作为几进制转换为十进制整数。详见 int()
float(x)	将X装换为浮点数。详见 float()
complex(real [, imag])	生成复数。real 为实部，imag为虚部(imag可省略，默认为0)。详见 complex()
str(x)	将对象 x 转换为字符串
repr(x)	将对象完全的转换为字符串，不仅仅只转换对象X的值，而是完整的转换值所包含的所有字符
eval(str)	将字符串对象转换为Python的表达式，并且将表达式执行后返回结果对象，参数必须是字符串、字节或代码对象。
chr(x)	将一个整数转换为一个Unicode字符
ord(x)	将一个字符转换为它的整数值
hex(x)	将一个整数转换为一个十六进制字符串
oct(x)	将一个整数转换为一个八进制字符串
bin(x)	将一个整数转换为一个二进制字符串
list(s)	将序列 s 转换为一个列表
tuple(s)	将序列 s 转换为一个元组

实例1

# int() 函数，将对象转换为整数
str1 = "10"
num1 = int(str1)
num2 = int(str1, 8)
num3 = int(3.99)
print("num1 =", num1)
print("num2 =", num2)
print("num3 =", num3)

# float() 函数，将对象转换为浮点数
str2 = "123"
f1 = float(str2)
print("f1 =", f1)

# complex() 函数，将对象转换为复数
z1 = 10+5j
z2 = complex(7, 3)
z3 = complex(8)
print("z1 =", z1)
print("z2 =", z2)
print("z3 =", z3)

输出：

num1 = 10
num2 = 8
num3 = 3
f1 = 123.0
z1 = (10+5j)
z2 = (7+3j)
z3 = (8+0j)

实例2

# str() 函数，将对象转换为字符串
n1 = 789
s1 = str(n1)
print("s1 =", s1)
print("s1的类型为", type(s1))

# repr() 函数，将对象完全的转换为字符串
print(repr("10+3"))

# eval() 函数，将字符串对象转换为Python的表达式
str3 = "10+3"
str4 = "3.14"
list1 = "[10, 20, 30, 40, 50]"
e1 = eval(str3)
e2 = eval(str4)
e3 = eval(list1)[0]
e4 = eval(list1)
print("e1 =", e1)
print("e2 =", e2)
print("e3 =", e3)
print("e4 =", e4[1])
print("e1的类型为", type(e1))
print("e2的类型为", type(e2))
print("e3的类型为", type(e3))
print("e4的类型为", type(e4))

输出：

s1 = 789
s1的类型为 <class ‘str’>
‘10+3’
e1 = 13
e2 = 3.14
e3 = 10
e4 = 20
e1的类型为 <class ‘int’>
e2的类型为 <class ‘float’>
e3的类型为 <class ‘int’>
e4的类型为 <class ‘list’>

实例3

# chr() 函数，将十进制数字装换为相应的Unicode字符
print(chr(97))

# ord 函数，将一个字符转换为相应的Unicode码
print(ord("a"))

# hex() 函数，将一个十进制整数转换为十六进制
print(hex(16))

# o() 函数，将一个十进制整数转换为八进制
print(oct(8))

# hex() 函数，将一个十进制整数转换为二进制
print(bin(2))

输出：

a
97
0x10
0o10
0b10

三、数字类型(Numbers)

Python中有三种数字类型：整数(int)、浮点数(float)、复数(complex)。

数字是由数字字面值或内置函数与运算符的结果来创建的，可以使用构造器 int()、 float()、 complex() 生成相应指定类型的数字。

Python 完全支持混合算术：当一个二元运算符用于不同数字类型的操作数时，具有“较窄” 类型的操作数会被扩展为另一个操作数的类型，整数比浮点数更窄，浮点数又比复数更窄， 混合类型数字之间的比较也使用相同的规则。

2.1 整数(int)

整数具有无限的精度。整数类型包含布尔值，布尔值属于整数的子类型。不带修饰的整数字面值（包括十六进制、八进制和二进制数）会生成整数。
Python有小整型常量池机制，存放着 -5 ~ 256 这262个数值，即Python在执行时就创建好了这262个数值的地址空间与相应的数值。
实例

a = 10  # 十进制整数
b = 0b10  # 二进制整数
c = 0o10  # 八进制整数
d = 0x10  # 十六进制整数
print("a =", a)  # 以十进制的方式输出a，下同
print("b =", b)
print("c =", c)
print("d =", d)
print(type(a))  # 内置的 type() 函数可以用来查询变量所指的对象类型。
print("true") if a else print("false")  # 三目运算，判断 a 的值为真或假

输出：

a = 10
b = 2
c = 8
d = 16
<class ‘int’>
true

2.1.1布尔(bool)

布尔类型有两个布尔值，分别为真值True、假值False。会被视为布尔类型(bool)中假值的有如下三种：

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

产生布尔值结果的运算和内置函数一般返回 0 或 False 作为假值，1 或 True 作为真值，除非另行说明。 （重要例外：布尔运算 or 和 and 总是返回其中一个操作数。）

在Python中允许“非零即真”的说法。

实例

a = 2+3
b1 = 5 == a
b2 = 6 == a
print("b1 =", b1)
print("b2 =", b2)
print("b1 + 1=", (b1 + 1))
print("b2 + 1=", (b2 + 1))
print("b1的类型为", type(b1))
print("b2的类型为", type(b2))
if a:
    print("a =", a)

输出：

b1 = True
b2 = False
b1 + 1= 2
b2 + 1= 1
b1的类型为 <class ‘bool’>
b2的类型为 <class ‘bool’>
a = 5

2.2 浮点数(float)

浮点数使用C语言中的 double 来实现，包含小数点或指数符号(科学计数法)的数字字面值都会生成浮点数。可以使用标准库中的decimal.Decimal¹自定义浮点数的精度。
实例

a = 3.14
b = 0.314E+2  # 指数形式的浮点数，即科学计数法
print("a =", a)  # 以浮点的方式输出a，下同
print("b =", b)
print(type(a))
print(type(b))

输出：

a=3.14
b=31.4
<class ‘float’>
<class ‘float’>

2.3 复数(complex)

复数包含实部和虚部，分别以浮点数表示。在数字字面值末尾加上 ‘j’ 或 ‘J’ 会生成虚数（实部为零的复数），你可以将其与整数或浮点数相加来得到具有实部和虚部的复数。假设有一个复数 z，可以使用 z.real 提取复数中实部、 z.imag 提取复数中虚部。
实例

x = 2+3j
z = 7J
print("x =", x)
print("z =", z)
print("z的实部为", z.real)  # 提取复数的实部
print("z的虚部为", z.imag)  # 提取复数的虚部
z += 5  # 复数的运算
print("z + 5 =", z)  # 以字符串的形式格式化输出复数 z
print("z的共轭复数为", z.conjugate())  # conjugate()用来求一个复数的共轭复数。请参阅：2.4数字类型的运算
print(type(x))
print(type(z))

输出：

x = (2+3j)
z = 7j
z的实部为 0.0
z的虚部为 7.0
z + 5 = (5+7j)
z的共轭复数为 (5-7j)
<class ‘complex’>
<class ‘complex’>

2.4 数字类型的运算

数字类型（复数不能参与某些运算）都支持下列运算²：（关于运算优先级，请参阅 “运算符优先级）

运算	解释	备注
-X	X 取反
+X	X 不变
X + Y	加法运算，计算X和Y的和
X - Y	减法运算，计算X和Y的差
X * Y	乘法运算，计算X和Y的乘积
X / Y	除法运算，计算X和Y的商
X % Y	取模运算，计算X和Y的余数，不可用于复数	（a）
X // Y	取整数运算，，计算X和Y的商数	（b）
X ** Y	幂运算，计算X的Y次幂	（c）
pow(X, Y)	幂运算，计算X的Y次幂。详见pow()	（c）
abs(X)	计算X的绝对值或大小。详见 abs()
divmod(X, Y)	求X和Y的商数与余数，结果如(X // Y, X % Y)，，不可用于复数。详见divmod()	（a）
complex(real [, imag])	生成复数。real 为实部，imag为虚部(imag可省略，默认为0)。详见 complex()	（d）
z.conjugate()	求复数z的 共轭复数
int(X)	将X转换为整数。详见 int()	（d）（e）
float(X)	将X装换为浮点数。详见 float()	（d）（f）
round(X[, n])	X被舍入到 n位小数，半数值会舍入到偶数，如果省略 n，则默认为 0。详见round()	（g）
math.trunc(X)	X被截断为 Integral (通常是整数) 。详见 math.trunc()	（g）
math.floor(X)	取 <= X 的最大整数 。详见 math.floor()	（g）
math.ceil(X)	取 >= X 的最大整数 。详见 math.ceil()	（g）

备注:
（a）不可直接用于复数，而应在适当条件下使用 abs() 转换为浮点数。
（b）也称为整数除法。 结果值是一个整数，但结果的类型不一定是 int。 运算结果总是向负无穷的方向舍入: 1 // 2为0， (-1) // (-2)为0，而(-1) // 2为-1，1 // (-2)为-1。
（c）Python 将 pow(0, 0) 和 0 ** 0 定义为 1，这是大多数编程语言的普遍做法。
（d）接受的数字字面值包括数码 0 到 9 或任何等效的 Unicode 字符（具有 Nd³ 特征属性的代码点）。
（e）从浮点数转换为整数会被舍入，或是像在 C 语言中一样被截断；⁴
（f）float 可以接受表示非数字的字符串 "nan" 或"NaN"，和表示正或负无穷的 inf（可以选择附带前缀 + 或 - ）。
（g）适用所有的 numbers.Real 类型 (int 和 float) 。

有关数字类型的详细说明，以及更多的运算与附加方法，请参阅 Python-文档>标准库>内置类型>数字类型 。

四、序列类型(Sequence)

有三种基本序列类型：list、tuple 和 range 对象。 此外还有 二进制数据 和 文本字符串 两种附加序列类型（分别为文本序列类型和二进制序列类型）。

3.1 字符串(str)

在 Python 中处理文本数据使用 str 对象，也称为字符串。字符串是由 Unicode 码位构成的不可变 文本序列类型 。 其他类型的对象可以通过使用 str() 构造器创建为字符串。
字符串字面值有多种不同的写法：

• 单引号：‘双引号’
• 双引号：“单引号”。
• 三重单引号：’’‘三重单引号’’’,
• 三重双引号：""“三重双引号”""

所有的空白字符都将包含在所属字符串字面值中，使用三重单/双引号的字符串可以跨越多行。
在字符串单一表达式中，只由空格分隔的多个字符串字面值会被隐式地转换为单个字符串字面值。 也就是说，(“a” “b” “c”) 等价于 “abc”。
Python 中不存在 C 语言中的“字符(char)”类型，对字符串做索引操作将产生一个长度为 1 的字符串。 也就是说，对于一个非空字符串 s，s[0] 等价于 s[0:1]。

字符串支持比较运算符，如："ABC" > "ABB"，那么结果为True，比较规则是先比较两个字符串第一个字符的ASCII码的大小，如果不相等则根据比较运算符得出结果 True 或 False ，如果相等继续向后依次比较，若所有字符的ASCII码均相等，那么这两个字符串是相等的。

字符串支持+加号运算符，意思是对左右两个字符串做连接后得出新的字符串，如："ABC" + "DEF" ，那么结果就是"ABCDEF" ；字符串还支持*乘号运算符，但仅限于一个参数是字符串另一个参数为整数，如"abc" * 3 ，结果就是"abcabcabc" 。
字符串除了支持+加号、*乘号运算符外，其他的如同 -减号、/除号、%取模、//取整除这些运算都不支持。
实例

s1 = '单引号'
s2 = "双引号"
s3 = '''三重单引号'''
s4 = """三重双引号"""
s5 = '''可以换行的
三重单引号
'''
s6 = """
可以换行的
 三重双引号
"""
s7 = str(complex(10, 5))
s8 = ("字" "符" "串")
print("s1 =", s1, "-- 类型为%s" % type(s1))
print("s2 =", s2, "  -- 类型为%s" % type(s2))
print("s3 =", s3, "  -- 类型为%s" % type(s3))
print("s4 =", s4, "  -- 类型为%s" % type(s4))
print("s5 =", s5, "  -- 类型为%s" % type(s5))
print("s6 =", s6, "  -- 类型为%s" % type(s6))
print("s7 =", s7, "  -- 类型为%s" % type(s7))
print("s8 =", s8, "  -- 类型为%s" % type(s8))
print("s1的第一个字符 = ", s1[0], "  -- 类型为%s" % type(s1[0]))
print('"abc" > "abb" 结果为：', ("abc" > "abb"))
print('"abc" + "def" 结果为：', ("abc" + "def"))
print(3 * "abc")

输出：

s1 = 单引号 – 类型为<class ‘str’>
s2 = 双引号 – 类型为<class ‘str’>
s3 = 三重单引号 – 类型为<class ‘str’>
s4 = 三重双引号 – 类型为<class ‘str’>
s5 = 可以换行的
三重单引号
– 类型为<class ‘str’>
s6 =
可以换行的
三重双引号
– 类型为<class ‘str’>
s7 = (10+5j) – 类型为<class ‘str’>
s8 = 字符串 – 类型为<class ‘str’>
s1的第一个字符 = 单 – 类型为<class ‘str’>
“abc” > “abb” 结果为：True
“abc” + “def” 结果为：abcdef
abcabcabc

3.X 序列类型的通用操作

3.X.1序列切片

lists = "0123456789"
#        @123456789# ,步长为正数时（“@”和“#”表示终止值的位置）
#       %012345678&  ,步长为负数时（“%”和“$”表示终止值的位置）
print(lists[::1])  # 等同于 lists[@:#:1]，步长值为正数时做 顺向 切片操作
print(lists[::-1])  # 等同于 lists[&:%:-1]，步长值为负数时做 逆向 切片操作

输出：

0123456789
9876543210

有关序列类型通用操作的详细说明，请参阅 Python-文档>标准库>内置类型>序列类型>通用序列操作 。

…
…
…（待完善）…

---

参考资料(如有侵权，请联系作者删除内容)：

• Python 3.8.0 官方文档-内置类型。

---

1. 请参阅 Decimal 对象 查看完整定义。 ↩︎

2. 请参阅 math 和 cmath 模块，查看更多的算数（数学）运算 ↩︎

3. 请参阅 http://www.unicode.org/Public/12.1.0/ucd/extracted/DerivedNumericType.txt/ 查看具有 Nd 特征属性的代码点的完整列表。 ↩︎

4. 请参阅 math.floor() 和 math.ceil() 函数查看转换的完整定义。 ↩︎