Python Number类型详解！

发表于 更新于 分类于 阅读次数： 本文字数： 5k 阅读时长 ≈ 5 分钟

嗨，你好啊，我是猿java

在 Python 中，“Number”是一个类别，包含不同类型的数值数据。Python 支持多种类型的数字，包括整数(int)、浮点数(Float)和复数(Complex)。这篇文章，我们将分析 Python的每种 Number类型以及和 Java语言的对比。

Python int

Python 的 int（整数）是一个包含负数的整数，不包括小数。在 Python 中，整数值的长度没有限制。

下面通过几个示例展示 Python 的 int 使用：

示例 1：创建整数并检查类型

1
2
3
4
num = -8

# 打印数据类型
print(type(num))

输出：

1
<class 'int'>

示例 2：对整数类型执行算术操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
a = 5
b = 6

# 加法
c = a + b
print("加法:", c)

d = 9
e = 6

# 减法
f = d - e
print("减法:", f)

g = 8
h = 2

# 除法
i = g // h
print("除法:", i)

j = 3
k = 5

# 乘法
l = j * k
print("乘法:", l)

m = 25
n = 5

# 取模
o = m % n
print("取模:", o)

p = 6
q = 2

# 指数
r = p ** q
print("指数:", r)

输出：

1
2
3
4
5
6
加法: 11
减法: 3
除法: 4
乘法: 15
取模: 0
指数: 36

Python Float

Float（浮点数）是具有浮点表示的实数。它通过小数点指定。可选地，字符 e 或 E 后跟正或负整数可以附加以指定科学计数法。一些表示为浮点数的数字示例是 0.5 和 -7.823457。

它们可以直接通过输入带小数点的数字创建，或者通过对整数进行操作（如除法）创建。数字末尾的多余零会自动忽略。

下面通过几个示例展示 Python 的 Float 使用：

示例 1：创建浮点数并检查类型

1
2
3
4
num = 3/4

# 打印数据类型
print(type(num))

输出：

1
<class 'float'>

如我们所见，除以任何两个整数会产生一个浮点数。通过对两个浮点数、或一个浮点数和一个整数进行操作，也会产生浮点数。

1
2
3
num = 6 * 7.0

print(type(num))

输出：

1
<class 'float'>

示例 2：对浮点数类型执行算术操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
a = 5.5
b = 3.2

# 加法
c = a + b
print("加法:", c)

# 减法
c = a - b
print("减法:", c)

# 除法
c = a / b
print("除法:", c)

# 乘法
c = a * b
print("乘法:", c)

输出：

1
2
3
4
加法: 8.7
减法: 2.3
除法: 1.71875
乘法: 17.6

注意：浮点数的精度只有到小数点后 15 位，第 16 位可能不准确。

Python Complex

Complex（复数）是由实部和虚部组成的数。例如，3 + 4j 是一个复数，其中 3 是实部，4 乘以 j 是虚部。

下面通过几个示例展示 Python 的 Complex 使用：

示例 1：创建复数并检查类型

1
2
3
num = 6 + 9j

print(type(num))

输出：

1
<class 'complex'>

示例 2：对复数类型执行算术操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
a = 1 + 5j
b = 2 + 3j

# 加法
c = a + b
print("加法:", c)

d = 1 + 5j
e = 2 - 3j

# 减法
f = d - e
print("减法:", f)

g = 1 + 5j
h = 2 + 3j

# 除法
i = g / h
print("除法:", i)

j = 1 + 5j
k = 2 + 3j

# 乘法
l = j * k
print("乘法:", l)

输出：

1
2
3
4
加法: (3+8j)
减法: (-1+8j)
除法: (1.307692307692308+0.5384615384615384j)
乘法: (-13+13j)

Python 类型转换

接下来，我们分析 int，Float，Complex 这几种 Number类型之间是如何转换的。

使用算术运算：

我们可以使用加法、减法等运算隐式（自动）地改变数字的类型，如果其中一个操作数是浮点数。这种方法不适用于复数。

示例：使用算术运算进行类型转换

1
2
3
4
5
6
7
8
a = 1.6
b = 5

# c被转换成 float类型
c = a + b

print(c)
print(type(c))

输出：

1
2
6.6
<class 'float'>

使用内置函数

我们还可以使用内置函数如 int()、float() 和 complex() 显式地将一种类型转换为另一种类型。

示例：使用内置函数进行类型转换

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
a = 2
print(float(a))

b = 5.6
print(int(b))

c = '3'
print(type(int(c)))

d = '5.6'
print(type(float(c)))

e = 5
print(complex(e))

f = 6.5
print(complex(f))

输出：

1
2
3
4
5
6
2.0
5
<class 'int'>
<class 'float'>
(5+0j)
(6.5+0j)

需要注意的几个点：

  • 当我们将浮点数转换为整数时，小数部分会被截断
  • 不能将复数类型的数字转换为整数类型或浮点类型的数字
  • 不能对字符串应用复数的内置函数。

Python Decimal Numbers

和 Java一样，Python 对浮点数进行算术运算也可能会产生一些意想不到的结果，下面通过几个示例进行说明：

示例 1：1.1 + 2.2 = ?

很多人会认为这个运算的结果应该是 3.3，但 Python 给出的输出如下：

1
2
3
4
5
a = 1.1
b = 2.2
c = a + b

print(c)

输出：

1
3.3000000000000003

示例 2：1.2 - 1.0 = ?

我们会期望结果是 0.2，但让我们看看 Python 给出的输出。

1
2
3
4
5
a = 1.2
b = 1.0
c = a - b

print(c)

输出：

1
0.19999999999999996

大家可能会认为 Python 有问题，但实际上并不是。这与 Python 关系不大，而更多与底层平台如何处理浮点数有关。这是处理系统内部浮点数时常见的问题。这个问题是由于内部浮点数表示使用固定数量的二进制数字来表示小数而引起的。在许多情况下，某些小数在二进制中很难表示，因此会导致小的舍入误差。

在这种情况下，以 1.2 为例，0.2 在二进制中的表示是 0.00110011001100110011001100……，很难在内部存储这个无限小数。通常，一个浮点对象的值以固定精度（二进制浮点数，通常为 53 位）存储。因此，我们内部表示 1.2 为：

1
1.0011001100110011001100110011001100110011001100110011

这正好等于：

1
1.1999999999999999555910790149937383830547332763671875

对于这种情况，Python 的 decimal 模块可以解决问题。如前所述，浮点数的精度只有到小数点后 15 位，但在十进制数中，精度是用户定义的。它以我们在学校学习的方式对浮点数进行运算。

让我们看看上面两个示例，并尝试使用十进制数解决它们。

示例：

1
2
3
4
5
6
7
import decimal

a = decimal.Decimal('1.1')
b = decimal.Decimal('2.2')

c = a + b
print(c)

输出：

1
3.3

我们可以在以下情况下使用 decimal 模块：

  • 当我们希望自行定义所需的精度时
  • 对于需要精确十进制表示的金融应用程序

Python 和 Java数字类型的对比

Python 和 Java 都是强类型语言，但它们处理数值类型的方式有所不同。以下是 Python 数字类型和 Java 数字类型的对比：

整数类型

Python语言：

  • int: 在 Python 3 中，int 类型可以表示任意大小的整数，不存在 long 类型的区别。
    1
    2
    num = 123456789012345678901234567890
    print(type(num))  # 输出：<class 'int'>

Java语言：

  • byte: 8 位有符号整数，范围从 -128 到 127。
  • short: 16 位有符号整数，范围从 -32,768 到 32,767。
  • int: 32 位有符号整数，范围从 -2^31 到 2^31-1。
  • long: 64 位有符号整数，范围从 -2^63 到 2^63-1。
    1
    2
    int num = 1234567890;
    long bigNum = 1234567890123456789L;

浮点数类型

Python语言：

  • float: Python 的 float 类型是双精度浮点数（64 位），即 C 语言中的 double。
    1
    2
    num = 3.14159
    print(type(num))  # 输出：<class 'float'>

Java语言：

  • float: 32 位单精度浮点数。
  • double: 64 位双精度浮点数。
    1
    2
    float num = 3.14f;
    double bigNum = 3.14159;

复数类型

Python语言：

  • complex: Python 原生支持复数，使用 complex 类型表示，复数由实部和虚部组成。
    1
    2
    num = 2 + 3j
    print(type(num))  # 输出：<class 'complex'>

Java语言：

  • Java 没有内置的复数类型。如果需要处理复数，可以使用第三方库如 Apache Commons Math。

高精度类型

Python语言：

  • decimal: Python 提供 decimal 模块用于高精度十进制运算。
    1
    2
    3
    import decimal
    num = decimal.Decimal('3.14159')
    print(type(num))  # 输出：<class 'decimal.Decimal'>

Java语言：

  • BigDecimal: Java 提供 BigDecimal 类用于高精度十进制运算。
    1
    2
    import java.math.BigDecimal;
    BigDecimal num = new BigDecimal("3.14159");

类型转换

Python语言：

  • Python 使用内置函数进行类型转换，如 int(), float(), complex(), 和 str()。
    1
    2
    a = 5
    b = float(a)  # 转换为浮点数

Java语言：

  • Java 使用显式类型转换和包装类进行类型转换，如 (int), (double), Integer.parseInt(), Double.parseDouble()。
    1
    2
    int a = 5;
    double b = (double) a;  // 转换为浮点数

总结

本文我们分析了 Python 的 Number类型，它包含：

  • int
  • float
  • complex

接着，我们对比了 Java 和 Python 语言的数字类型：

  • 整数: Python 的 int 类型可以表示任意大小的整数，而 Java 有多种整数类型（byte, short, int, long）。
  • 浮点数: Python 使用 float 表示双精度浮点数，而 Java 有单精度和双精度浮点数（float, double）。
  • 复数: Python 原生支持复数，而 Java 需要使用第三方库。
  • 高精度: Python 使用 decimal 模块，Java 使用 BigDecimal 类。
  • 类型转换: Python 使用内置函数，Java 使用显式类型转换和包装类。

尽管语言语法上有差异，但是底层的逻辑是相通的。

学习交流

如果你觉得文章有帮助，请帮忙转发给更多的好友，或关注公众号：猿java，持续输出硬核文章。

drawing