Python入门：数字类型与运算

文章目录

[1. 整数类型（int）](#1. 整数类型（int）)
- [1.1 创建与进制表示](#1.1 创建与进制表示)
- [1.2 进制转换](#1.2 进制转换)
- [1.3 int() 函数转换](#1.3 int() 函数转换)
[2. 浮点数类型（float）](#2. 浮点数类型（float）)
- [2.1 创建与科学计数法](#2.1 创建与科学计数法)
- [2.2 取值范围与特殊值](#2.2 取值范围与特殊值)
- [2.3 float()函数转换](#2.3 float()函数转换)
- [2.4 精度问题](#2.4 精度问题)
[3. 数值运算](#3. 数值运算)
- [3.1 赋值运算符](#3.1 赋值运算符)
- [3.2 算数运算符](#3.2 算数运算符)
- [3.3 比较运算符](#3.3 比较运算符)
- [3.4 运算符优先级](#3.4 运算符优先级)
- - [3.4.1 涉及优先级（从高到低）](#3.4.1 涉及优先级（从高到低）)
  - [3.4.2 核心规则详解](#3.4.2 核心规则详解)
  - [3.4.3 避坑提醒](#3.4.3 避坑提醒)
[4. 类型判断与转换基础](#4. 类型判断与转换基础)
- [4.1 类型判断（两大核心函数）](#4.1 类型判断（两大核心函数）)
- - [4.1.1 type() ------ 精准查看数据原生类型](#4.1.1 type() —— 精准查看数据原生类型)
  - [4.1.2 isinstance() ------ 兼容判断（推荐业务常用）](#4.1.2 isinstance() —— 兼容判断（推荐业务常用）)
  - [4.1.3 实用判断小技巧](#4.1.3 实用判断小技巧)
- [4.2 类型转换](#4.2 类型转换)
- - [4.2.1 自动隐式类型转换（Python 自动执行）](#4.2.1 自动隐式类型转换（Python 自动执行）)
  - [4.2.2 手动强制类型转换](#4.2.2 手动强制类型转换)
补充：复数类型（complex）

Python 提供了多种内置的数据类型，用于存储和操作不同类型的信息。数字类型是 Python 最基础的数据类型，数值运算则是编程计算的核心能力。这里将系统讲解整数 int、浮点数 float 的定义、进制、精度与常用操作，全覆盖算术运算、比较运算、赋值运算及优先级，快速掌握 Python 数值计算能力。

1. 整数类型（int）

在 Python 中，整数类型（int） 用于表示正整数、负整数和零。在 Python 3 中，整数类型是没有大小限制的，可以表示任意大小的整数（受限于可用内存）。

这与 Python 2 不同，在 Python 2 中有 int 和 long 两种不同的整数类型。

1.1 创建与进制表示

整数可以直接赋值给变量，支持十进制、二进制、八进制和十六进制表示法，也可以使用 int() 函数将其他类型转换为整数。

python 复制代码

# 十进制：默认的表示方式。
x = 26

# 二进制：以 0b 或 0B 开头。
binary_num = 0b11010  # 等价于十进制的 26

# 八进制：以 0o 或 0O 开头。
octal_num = 0o32  # 等价于十进制的 26

# 十六进制：以 0x 或 0X 开头。
hex_num = 0x1A  # 等价于十进制的 26

# 使用 int() 函数将其他类型转换为整数
int_from_str = int("123")
int_from_float = int(123.45)
print(int_from_str)  # 输出: 123
print(int_from_float)  # 输出: 123

1.2 进制转换

bin()：十进制转换为二进制，输出形式是字符串
oct()：十进制转换为八进制，输出形式是字符串
hex()：十进制转换为十六进制，输出形式是字符串

python 复制代码

print(bin(10))     # 输出: '0b1010'
print(type(bin(10)))    # str类型

print(oct(15))     # 输出: '0o17'
print(type(oct(15)))    # str类型

print(hex(26))     # 输出: '0x1a'
print(type(hex(26)))    # str类型

1.3 int() 函数转换

int()函数是 Python 中的一个内置函数，主要用于将其他数据类型转换为整数类型。基本语法是int(x, base=n)，其中x是要转换的对象，base是可选参数，用于指定进制。

当x是整数或浮点数时，会直接将其转换为整数。浮点数向下取整转换为整数(即仅保留整数部分)。

当x是字符串时，会尝试将字符串转换为整数。此时字符串中的内容应该是合法的数字表示形式。如果字符串中包含非数字字符（除了正负号），则会引发 ValueError。例如，int("abc")会抛出错误。

base参数可以指定不同进制。例如，2 表示二进制，8 表示八进制，10表示十进制，16 表示十六进制。

python 复制代码

print(int(100))             # 输出100
print(int(3.5415))          # 输出3
print(int('-100'))          # 输出-100
print(int('100',2))         # 指定为二进制，输出4

使用下划线分隔

为了提高数字的可读性，对于较长的整数，可以使用下划线作为分隔符。例如，123_456_789 与 123456789 是相同的整数。

python 复制代码

 print(123456789 == 123_456_789)     # True

2. 浮点数类型（float）

在 Python 中，浮点数类型（float） 用于表示带有小数点的实数。浮点数可以包含小数部分，并且支持科学计数法表示非常大或非常小的数值。

2.1 创建与科学计数法

浮点数可以直接赋值给变量或通过表达式计算得到。一般以十进制表示，由整数和小数部分组成。对于很大或者很小的浮点型，可以使用科学计数法表示；也可以使用 float() 函数将其他类型转换为浮点数。

python 复制代码

# 直接赋值
pi = 3.14159

# 科学计数法：使用 e 或 E 表示指数部分。
speed_of_light = 2.998e8  # 等价于 299,800,000
planck_constant = 6.626e-34  # 等价于 0.000...06626 (34 位小数)

# 使用 float() 函数将其他类型转换为浮点数
float_from_str = float("123.45")
float_from_int = float(123)
print(float_from_str, float_from_int)  # 输出: 123.45 123.0

2.2 取值范围与特殊值

Python 浮点数通常采用双精度（64 位）表示。这意味着它们具有特定的取值范围和一些特殊的值。Python 浮点数的最大和最小值如下：

python 复制代码

# 最大正浮点数：
 - 1.7976931348623157e+308
# 最小正非零浮点数：
 - 2.2250738585072014e-308

可以使用内置的 sys 模块 来获取最大和最小值这些极限值：

python 复制代码

import sys
print("最大正浮点数:", sys.float_info.max)
print("最小正非零浮点数:", sys.float_info.min)

# 输出
最大正浮点数: 1.7976931348623157e+308
最小正非零浮点数: 2.2250738585072014e-308

浮点数超出这个范围的数值会导致溢出或下溢。如果一个数值太大，超出了最大正浮点数，它将被表示为 inf（正无穷大）；如果一个数值太小，接近于零但小于最小正非零浮点数，它将被表示为 0.0 或 -0.0。

浮点数支持的一些特殊的值：

正无穷大 (inf)：表示比任何其他数值都大的正数。

负无穷大 (-inf)：表示比任何其他数值都小的负数。

非数字 (NaN)：表示"不是一个数"，通常用于表示未定义或不可表示的结果，如 0/0 或 inf - inf。

2.3 float()函数转换

当传入整数时，float()函数会将整数转换为对应的浮点数。

当传入字符串时，字符串的内容应该是合法的数字表示形式。如果字符串中包含非数字字符（除了正负号、小数点和科学计数法相关的字符e或E），则可能会引发ValueError。对于科学计数法表示的字符串，float()函数也能正确转换。

此外，对于空字符串或仅包含空白字符的字符串，也会引发 ValueError

python 复制代码

print(float("3.14"))   # 3.14
print(float("-10.5"))  # -10.5
print(float("2.71828e-1"))   # 0.271828
print(float("abc"))  # 引发 ValueError

2.4 精度问题

计算机内部以二进制形式存储浮点数，一些十进制小数无法精确转换为二进制小数，导致存储和计算时产生舍入误差。例如：

python 复制代码

a = 0.1 + 0.2
print(a)    # 输出: 0.30000000000000004

这是因为 0.1 和 0.2 在二进制中是无限循环小数，不能被精确存储。为了处理这种情况，可以使用 Python 的 decimal 模块来获得更高的精度。

python 复制代码

from decimal import Decimal
a = Decimal('0.1') + Decimal('0.2')
print(a)    # 输出: 0.3

因此建议在实际编程中处理浮点数时

避免直接比较浮点数：由于精度问题，两个看似相等的浮点数可能并不完全相等。建议使用近似比较的方法。

使用 decimal 模块：对于需要高精度计算的场景（如金融计算），推荐使用 decimal 模块。

3. 数值运算

Python 提供了丰富的运算符体系，涵盖算术运算、比较运算、赋值运算等基础操作。熟练掌握运算符的用法、运算规则与优先级，是编写简洁、高效、无错误代码的关键。

3.1 赋值运算符

赋值运算符用于将数据或表达式结果绑定到变量，是编程中最基础、最常用的操作。

基本赋值运算符（=）

最常用的赋值运算符，将右侧的值或表达式结果赋给左侧变量，是所有赋值操作的基础。

python 复制代码

# 将整数赋值给变量
num = 10
print(num)  # 输出: 10

# 将字符串赋值给变量
message = "Hello, Python!"
print(message)  # 输出: Hello, Python!

# 将表达式的结果赋值给变量
result = 2 + 3
print(result)  # 输出: 5

复合赋值运算符

复合赋值运算符是在基本赋值运算符的基础上，结合其他运算符（如算术运算符、位运算符等）形成的，它可以简化代码。

python 复制代码

# +=（加法赋值）：将右侧的值加到左侧变量上，并将结果重新赋给左侧变量。
a = 5
a += 3  # 相当于 a = a + 3
print(a)  # 输出: 8

# -=（减法赋值）：从左侧变量中减去右侧的值，并将结果重新赋给左侧变量。
b = 10
b -= 4  # 相当于 b = b - 4
print(b)  # 输出: 6

# *=（乘法赋值）：将左侧变量乘以右侧的值，并将结果重新赋给左侧变量。
c = 2
c *= 5  # 相当于 c = c * 5
print(c)  # 输出: 10

# /=（除法赋值）：将左侧变量除以右侧的值，并将结果重新赋给左侧变量，结果为浮点数。
d = 15
d /= 3  # 相当于 d = d / 3
print(d)  # 输出: 5.0

# //=（整除赋值）：将左侧变量整除右侧的值，并将结果重新赋给左侧变量。
e = 17
e //= 3  # 相当于 e = e // 3
print(e)  # 输出: 5

# %=（取模赋值）：将左侧变量对右侧的值取模，并将结果重新赋给左侧变量。
f = 13
f %= 5  # 相当于 f = f % 5
print(f)  # 输出: 3

# **=（幂赋值）：将左侧变量的右侧次幂的值赋给左侧变量。
g = 2
g **= 3  # 相当于 g = g ** 3
print(g)  # 输出: 8

多重赋值

Python 支持同时对多个变量进行赋值，这种方式可以让代码更加简洁。

python 复制代码

# 多个变量赋相同的值
x = y = z = 1
print(x, y, z)  # 输出: 1 1 1

# 多个变量赋不同的值
a, b, c = 1, 2, 3
print(a, b, c)  # 输出: 1 2 3

# 交换两个变量的值
m = 5
n = 10
m, n = n, m
print(m, n)  # 输出: 10 5

序列解包赋值（提前了解）

可直接将列表、元组等序列中的元素依次赋值给多个变量。

python 复制代码

# 列表解包
my_list = [1, 2, 3]
p, q, r = my_list
print(p, q, r)  # 输出: 1 2 3

# 元组解包
my_tuple = (4, 5, 6)
s, t, u = my_tuple
print(s, t, u)  # 输出: 4 5 6

赋值运算符的优先级相对较低，在一个表达式中，会先计算其他运算符，最后进行赋值操作。

3.2 算数运算符

算术运算符用于数值计算，同时对字符串、列表、集合等类型也有特殊作用。

加法运算符（+）

在 Python 里，加法运算符的作用丰富多样，主要取决于操作数的数据类型。当操作数为数值类型（如整数、浮点数）时，+ 用于执行加法运算，将两个数值相加得到一个新的数值结果。

python 复制代码

# 整数相加
int_result = 5 + 3
print(int_result)  # 输出: 8

# 浮点数相加
float_result = 2.5 + 3.7
print(float_result)  # 输出: 6.2

# 整数与浮点数相加
mixed_result = 4 + 2.1
print(mixed_result)  # 输出: 6.1

若操作数为字符串类型，+ 可将两个或多个字符串连接起来，形成一个新的字符串。

python 复制代码

str1 = "Hello"
str2 = " World"
combined_str = str1 + str2
print(combined_str)  # 输出: Hello World

对于列表或元组类型等可迭代对象时，+ 会把多个对象合并成一个新的对象。

python 复制代码

# 列表合并
list1 = [1, 2, 3]
list2 = [4, 5, 6]
merged_list = list1 + list2
print(merged_list)  # 输出: [1, 2, 3, 4, 5, 6]

# 元组合并
tuple1 = (1, 2)
tuple2 = (3, 4)
combined_tuple = tuple1 + tuple2
print(combined_tuple)  # 输出: (1, 2, 3, 4)

总之，加法运算符可用于两个数值相加，也可用于拼接字符串、列表等可迭代对象，且不会改变原始对象的。

减法运算符（-）

当操作数为数值类型（整数、浮点数等）时，- 用于执行减法运算，即从一个数中减去另一个数，得到差值。

python 复制代码

# 整数减法
int_result = 8 - 3
print(int_result)  # 输出: 5

# 浮点数减法
float_result = 5.2 - 2.1
print(float_result)  # 输出: 3.1

# 整数与浮点数混合减法
mixed_result = 7 - 3.5
print(mixed_result)  # 输出: 3.5

对于单个数值类型的操作数，- 可以将其变为负数，也就是取该数的相反数。

python 复制代码

positive_num = 10
negative_num = -positive_num
print(negative_num)  # 输出: -10

negative_float = -3.7
print(negative_float)  # 输出: -3.7

在 Python 中，对于集合（set 或 frozenset）类型的操作数，- 用于计算两个集合的差集。差集是指属于第一个集合但不属于第二个集合的所有元素组成的集合。

python 复制代码

set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}
difference_set = set1 - set2
print(difference_set)  # 输出: {1, 2}

综上所述，- 运算符在 Python 中的作用涵盖了基本的数值运算、集合操作以及自定义对象的减法逻辑实现。

乘法运算符（*）

当操作数为数值类型（如整数、浮点数）时，* 用于执行乘法运算，得到两个数的乘积。

python 复制代码

# 整数乘法
int_result = 5 * 3
print(int_result)  # 输出: 15

# 浮点数乘法
float_result = 2.5 * 4
print(float_result)  # 输出: 10.0

# 整数与浮点数相乘
mixed_result = 3 * 2.1
print(mixed_result)  # 输出: 6.3

对于字符串、列表、元组等序列类型，* 可以将序列重复指定的次数，生成一个新的序列。

python 复制代码

# 字符串重复
str_result = "abc" * 3
print(str_result)  # 输出: abcabcabc

# 列表重复
list_result = [1, 2] * 4
print(list_result)  # 输出: [1, 2, 1, 2, 1, 2, 1, 2]

# 元组重复
tuple_result = (3, 4) * 2
print(tuple_result)  # 输出: (3, 4, 3, 4)

除法运算符（/）

当操作数为数值类型（整数、浮点数等）时，/ 执行常规的除法运算，无论操作数是否为整数，结果都会是浮点数。这与 Python 2 有所不同，在 Python 2 中两个整数相除结果为整数（会截断小数部分），而 Python 3 中 / 始终返回浮点数结果。

python 复制代码

# 两个整数相除
result1 = 10 / 3
print(result1)  # 输出: 3.3333333333333335

# 整数与浮点数相除
result2 = 8 / 2.5
print(result2)  # 输出: 3.2

# 两个浮点数相除
result3 = 4.5 / 1.5
print(result3)  # 输出: 3.0

整除运算符（//）

当对两个数值（整数、浮点数）进行操作时，// 会执行除法运算并返回商的整数部分，也就是向下取整的结果。

python 复制代码

# 整数之间的整除
result1 = 10 // 3
print(result1)  # 输出: 3

# 浮点数之间的整除
result2 = 10.5 // 2.3
print(result2)  # 输出: 4.0

# 整数与浮点数的整除
result3 = 15 // 2.0
print(result3)  # 输出: 7.0

取模运算符（%）

在数值运算里，% 用于计算两个数相除后的余数。操作数可以是整数、浮点数等数值类型。

bash 复制代码

# 整数取模：计算 10 除以 3 的余数
result1 = 10 % 3
print(result1)  # 输出: 1

# 浮点数取模：计算 10.5 除以 2.3 的余数
result2 = 10.5 % 2.3
print(result2)  # 输出: 1.3

// 运算符经常和取模运算符 % 一起使用，用于分离数值的整数部分和余数部分。

取模运算常被用于循环和周期性任务中，例如实现循环索引、判断奇偶性等。

幂运算符（**）

主要用于计算一个数的指定次幂，即对两个数值类型（整数、浮点数等）的操作数，计算左操作数的右操作数次方。

python 复制代码

# 整数的幂运算：计算 2 的 3 次方
result1 = 2 ** 3
print(result1)  # 输出: 8

# 浮点数的幂运算：计算 2.5 的 2 次方
result2 = 2.5 ** 2
print(result2)  # 输出: 6.25

# 负数和分数次幂
# 计算 4 的 -2 次方
result3 = 4 ** -2
print(result3)  # 输出: 0.0625

# 计算 8 的 1/3 次方（开立方）
result4 = 8 ** (1/3)
print(result4)  # 输出: 2.0

运算规则

当不同数据类型进行运算时，Python 会进行类型转换。例如整数和浮点数运算，结果会是浮点数。

python 复制代码

int_num = 5
float_num = 2.5
print(int_num + float_num)  # 输出 7.5

有些运算符对操作数有特定要求，比如字符串和整数不能直接进行减法运算，会抛出 TypeError 异常。

python 复制代码

try:
    str_val = "abc"
    num_val = 1
    print(str_val - num_val)
except TypeError as e:
    print(f"错误信息: {e}")   
# 错误信息: unsupported operand type(s) for -: 'str' and 'int'

算术运算符优先级

当一个表达式中包含多个算数运算符时，Python 会按照一定的优先级进行计算。优先级从高到低大致如下：

复制代码

**（幂运算）
*、/、//、%（乘、除、整除、取模）
+、-（加、减）

可以使用括号 () 来改变运算的优先级，括号内的表达式会先进行计算。

python 复制代码

result1 = 2 + 3 * 4  # 先乘后加，结果为 14
result2 = (2 + 3) * 4  # 先加后乘，结果为 20
print(result1)
print(result2)

3.3 比较运算符

在 Python 中，比较运算符用于比较两个值或表达式的大小关系，其运算结果是布尔类型（True 或 False）。

等于运算符（==）

在 Python 里，== 是用于比较两个对象是否相等的比较运算符。

在数值类型（整数、浮点数）中，== 用于判断两个数值是否相等，比较的是数值的大小。

python 复制代码

# 整数比较
int1 = 5
int2 = 5
print(int1 == int2)  # 输出: True

# 浮点数比较
float1 = 3.14
float2 = 3.14
print(float1 == float2)  # 输出: True

# 整数和浮点数比较
int_num = 10
float_num = 10.0
print(int_num == float_num)  # 输出: True

在字符串类型中，== 比较两个字符串的内容是否完全相同，包括字符的顺序和大小写。

python 复制代码

str1 = "Hello"
str2 = "Hello"
print(str1 == str2)  # 输出: True

str3 = "hello"
print(str1 == str3)  # 输出: False

判断两个布尔值是否相等。

python 复制代码

bool1 = True
bool2 = True
print(bool1 == bool2)  # 输出: True

bool3 = False
print(bool1 == bool3)  # 输出: False

列表和元组类型中，会逐个比较其中对应位置的元素，只有当两个对象的长度相等且对应位置的元素都相等时，才返回 True。

python 复制代码

# 列表类型
list1 = [1, 2, 3]
list2 = [1, 2, 3]
print(list1 == list2)  # 输出: True

list3 = [1, 3, 2]
print(list1 == list3)  # 输出: False

# 元组类型
tuple1 = (1, 2)
tuple2 = (1, 2)
print(tuple1 == tuple2)  # 输出: True

tuple3 = (2, 1)
print(tuple1 == tuple3)  # 输出: False

对于集合，== 比较两个集合是否包含相同的元素，不考虑元素的顺序。

python 复制代码

set1 = {1, 2, 3}
set2 = {3, 2, 1}
print(set1 == set2)  # 输出: True

set3 = {1, 2}
print(set1 == set3)  # 输出: False

字典类型 == 比较两个字典的键值对是否完全相同，键和对应的值都要相等。

python 复制代码

dict1 = {'a': 1, 'b': 2}
dict2 = {'a': 1, 'b': 2}
print(dict1 == dict2)  # 输出: True

dict3 = {'a': 1, 'b': 3}
print(dict1 == dict3)  # 输出: False

不等于运算符（!=）

不等于运算符（!=）与等于运算符（==）的功能完全相反，可以参考了解。

大于运算符（>）

在 Python 里，> 是大于比较运算符，用于判断左边的操作数是否大于右边的操作数，若满足条件则返回 True，否则返回 False。

对于整数、浮点数等数值类型，> 用于比较它们的大小。

python 复制代码

# 整数比较
int1 = 10
int2 = 5
print(int1 > int2)  # 输出: True

# 浮点数比较
float1 = 3.14
float2 = 2.71
print(float1 > float2)  # 输出: True

# 整数和浮点数混合比较
num1 = 5
num2 = 5.5
print(num1 > num2)  # 输出: False

字符串比较是基于字典序（即字符的 Unicode 码值）进行的，Python 会从两个字符串的第一个字符开始逐个比较，直到找到不同的字符或者其中一个字符串结束。

python 复制代码

str1 = "apple"
str2 = "banana"
print(str1 > str2)  # 输出: False，因为 'a' 的 Unicode 码值小于 'b'

str3 = "hello"
str4 = "he"
print(str3 > str4)  # 输出: True，因为 'hello' 比 'he' 长，且前两个字符相同

Python 支持链式比较，即可以同时使用多个 > 运算符进行连续比较。

python 复制代码

a = 10
b = 5
c = 2
print(a > b > c)  # 输出: True，等价于 (a > b) and (b > c)

在 datetime 模块中，日期和时间对象可以使用 > 比较先后顺序。
python 复制代码
from datetime import datetime

date1 = datetime(2023, 1, 1)
date2 = datetime(2024, 1, 1)
print(date2 > date1)  # 输出: True，因为 2024 年 1 月 1 日晚于 2023 年 1 月 1 日

大于等于运算符（>=）、小于运算符（<）、小于等于运算符（<=）

这三种比较运算符都可以参考大于运算符的内容进行了解。

比较对象的引用和值

对于对象类型（如列表、字典等），== 比较的是对象的值，而 is 比较的是对象的引用（即是否为同一个对象）。

python 复制代码

list3 = [1, 2, 3]
list4 = [1, 2, 3]
list5 = list3

print(list3 == list4)  # 输出: True，值相等
print(list3 is list4)  # 输出: False，不是同一个对象
print(list3 is list5)  # 输出: True，是同一个对象

3.4 运算符优先级

在混合运算表达式中，Python 会按照固定优先级自动判定计算顺序：优先级越高，越优先执行；同级运算符，默认从左往右算；特殊运算符遵循专属结合规则。

3.4.1 涉及优先级（从高到低）

括号 ( )：强制最高优先级，括号内永远最先计算
** 幂运算：唯一右结合，从右往左算
* / // %：乘、除、整除、取模（同级，左到右）
+ -：加法、减法（同级，左到右）
< <= > >=：大小比较运算符
== !=：等于、不等于判断
所有赋值运算符：=、+=、-=、*=、/= 等（优先级最低，最后执行）

3.4.2 核心规则详解

括号优先（万能用法）：不确定计算顺序时，直接加括号，可读性最强，杜绝逻辑错误。

python 复制代码

print(2 + 3 * 4)       # 14，先乘后加
print((2 + 3) * 4)     # 20，括号强制先算加法

幂运算特殊结合性：** 是右结合，同级从右向左计算，和其他运算符相反：

python 复制代码

print(2 ** 3 ** 2)   # 等价 2 ** (3**2) = 2**9 = 512
print((2 ** 3) ** 2) # 手动改顺序：8**2 = 64

同级运算符：从左往右算：乘、除、整除、取模优先级一致，严格从左向右执行：

python 复制代码

print(10 / 2 * 5)   # 先除后乘：5 * 5 = 25
print(10 * 2 / 5)   # 先乘后除：20 / 5 = 4

算术优先于比较：程序会先算完所有加减乘除，再做大小/相等判断：

python 复制代码

print(2 + 3 * 2 > 7)  
# 步骤1：3*2=6 → 步骤2：2+6=8 → 步骤3：8>7 → True

赋值永远最后执行：先计算右侧所有表达式结果，再赋值给左侧变量：

python 复制代码

a = 10
a *= 3 + 2  
# 步骤1：3+2=5 → 步骤2：a = 10 * 5 → 50

3.4.3 避坑提醒

浮点数混合运算、多层嵌套公式，优先用括号，别靠硬记优先级；
幂运算多层叠加，一定要手动加括号明确顺序；
比较运算不要省略算术括号，避免预判出错。

4. 类型判断与转换基础

Python 是动态弱类型语言 ：变量无需声明类型、赋值即创建；运算时会自动隐式转换，也支持手动强制转换。

常用基础类型：int整型、float浮点、str字符串、bool布尔，包括后续集合、列表等。

4.1 类型判断（两大核心函数）

4.1.1 type() ------ 精准查看数据原生类型

语法：type(数据/变量)
作用：返回对象原生所属类型，单纯看是什么类型，不做父子兼容判断。

python 复制代码

print(type(10))        # <class 'int'>
print(type(3.14))      # <class 'float'>
print(type("hello"))   # <class 'str'>
print(type(True))      # <class 'bool'>

# 注意：布尔本质是int子类，但type严格区分
print(type(True) == type(1))  # False

4.1.2 isinstance() ------ 兼容判断（推荐业务常用）

语法：isinstance(数据, 类型) / isinstance(数据, (类型1,类型2))
作用：判断数据是否属于某个类型/子类，支持多类型匹配，更贴合实际开发。

python 复制代码

# 单类型判断
print(isinstance(True, int))    # True  布尔是int子类
print(isinstance(10, float))    # False

# 多类型匹配：满足其一就返回True
num = 20
print(isinstance(num, (int, float)))  # True

4.1.3 实用判断小技巧

python 复制代码

# 判断是否纯数字（整型+浮点）
def is_number(x):
    return isinstance(x, (int, float))

print(is_number(666))   # True
print(is_number(3.14)) # True
print(is_number("88")) # False

4.2 类型转换

4.2.1 自动隐式类型转换（Python 自动执行）

不同类型混合运算，Python 自动向精度更高 的类型靠拢，转换优先级：bool → int → float。核心规则：

布尔参与运算：True=1，False=0
整型+浮点 → 自动转浮点
字符串不会自动参与数值运算，直接报错

python 复制代码

# 布尔转int
print(1 + True)    # 2
print(3 * False)  # 0

# int + float → 自动升为float
print(5 + 2.5)    # 7.5 结果为浮点型

# 报错示范：字符串不能和数字直接运算
# print(10 + "20")  # TypeError

4.2.2 手动强制类型转换

int() 转为整数
float() 转为浮点数
str() 转为字符串：所有基础类型都能直接转，变成文本格式

python 复制代码

print(str(123))    # "123"
print(str(3.14))   # "3.14"
print(str(True))   # "True"

bool() 转为布尔值（重点！空值/零为假）：判定 假（False） 的特殊值：0、0.0、空字符串""、空列表[]、空元组、空字典、None；其余所有值，全为 True

python 复制代码

# 空/零 → False
print(bool(0))       # False
print(bool(0.0))     # False
print(bool(""))      # False

# 非空/非零 → True
print(bool(1))       # True
print(bool(-5))      # True
print(bool("hello")) # True
print(bool("0"))     # True  注意：字符串"0"不是空值

补充：复数类型（complex）

在 Python 中，复数类型（complex） 用于表示数学中的复数。复数由实数部分和虚数部分组成，基本表示形式为 a + bj，其中a是实数部分，b是虚数部分，j是虚数单位（在数学中通常用i表示，但在 Python 中由于i已经用于其他用途，所以采用j来表示虚数单位）。

因为复数的使用场景往往是一些数学和科学计算领域以及工程领域，不怎么常用所以这里了解一下即可。

复数创建

python 复制代码

# 直接赋值
c = 3 + 4j         

##############################
# 使用 complex() 函数创建复数

c = complex()         # 无参数：默认创建 0j
print(c)  # 输出: 0j

c = complex(5)        # 单个参数：仅提供实部，默认虚部为 0
print(c)  # 输出: (5+0j)

c = complex(3, 4)     # 两个参数：分别提供实部和虚部 
print(c)  # 输出: (3+4j)

d = complex("5+6j")  # 字符串格式必须是有效的复数表示形式
print(d)  # 输出: (5+6j)

使用 .real 和 .imag 属性来访问复数的实部和虚部

python 复制代码

c = 3 + 4j
print(c.real)  # 输出: 3.0
print(c.imag)  # 输出: 4.0

conjugate() 方法返回复数的共轭

简单l理解，共轭复数就是实部相同，虚部互为相反数的复数。

python 复制代码

# 创建复数
z1 = 3 + 4j

# 获取共轭复数
z1_conjugate = z1.conjugate()

print(f"原始复数: {z1}")          # 输出: 原始复数: (3+4j)
print(f"共轭复数: {z1_conjugate}")  # 输出: 共轭复数: (3-4j)

以上就是 Python 数值类型与核心运算的全部内容，整数、浮点数、的基础特性，以及运算规则、类型判断与转换，都是入门必备的核心知识点。建议多动手实践，规避易错点，夯实基础，后续将继续讲解更灵活的数据类型，共同进步。