---

注释

• 单行注释：# 开头。

# 这是一个注释
print("Hello") # 行末注释

• 多行注释：三个引号 “”" 或 ‘’'。

"""
这是一个
多行注释
"""

变量&常量

• 定义：变量名 = 值（无需声明类型）。
• 原理：变量是标签，指向内存中的对象。

Java 对比：
Java：int a = 10; 声明类型，分配内存空间。
Python：a = 10。10 是一个对象，a 只是贴在 10 上面的标签。Python 中一切皆对象（包括整数）。

• 命名规范：
  • 只能包含字母、数字、下划线，不能以数字开头。
  • 区分大小写。
  • 常见的命名方法有三种：
    • 大驼峰命名法（upper camel case）：每个单词首字母大写，例如UpperCamelCase。
    • 小驼峰命名法（lower camel case）：第一个单词首字母小写, 之后每个单词首字母大写，例如lowerCamelCase。
    • 蛇形命名法（snake case）：单词间用下划线连接，例如snake_case（Python官方推荐）。
  • 关键字不能作为变量名（如 if, class, def）。
  • 在程序中定义后就不再修改的值为常量，Python中没有内置的常量类型（无 final 关键字）。一般约定使用全大写变量名来表示常量。

示例

# 变量以数字、字母、下划线命名，不能以数字开头，声明时不需要指定类型
"""
多行注释
在Python中一切皆对象
"""
my_var = 1
print(my_var)
# 打印my_var变量执行的1对象的地址
print(id(my_var))
my_var = 10
print(my_var)
print(id(my_var))
my_var2 = "hello"
print(my_var2)
my_var3 = 6.66
print(my_var3)
my_var4 = False
print(my_var4)
my_var5 = True
print(my_var5)
print("------------------------------")

# 给多个变量赋同一个值
a = b = c = 888
print(a)
print(b)
print(c)
print("------------------------------")

# 给多个变量同时赋值
x,y,z = 11,22,33
print(x)
print(y)
print(z)
print("------------------------------")

# 常量，常量使用大写字母表示
PI = 3.141592653589793
print(PI)

执行代码结果

1
140716218505656
10
140716218505944
hello
6.66
False
True
------------------------------
888
888
888
------------------------------
11
22
33
------------------------------
3.141592653589793

基本数据类型

Python 中一切皆对象，主要包含以下几种数据类型：

1.数值类型 (Numeric)

• int (整数)：无大小限制（Python 3），自动处理大整数溢出。

Java 对比：Java int 范围是 -2^31 ~ 2^31-1，超出需用 BigInteger。Python int 自动扩容，相当于内置了 BigInteger。

• float (浮点数)：带小数点的数（双精度，类似 Java double）。
• bool (布尔)：True 和 False（注意首字母大写）。

Java 对比：Java 是 true/false。Python 本质是整数 (True1, False0)，可直接参与数学运算（虽然不推荐）。

• complex (复数)：如 3 + 4j（科学计算常用）。

类型查看与判断案例：

num1 = True
num2 = 1
print(type(num1))                 # <class 'bool'>
print(type(num2))                 # <class 'int'>
print(isinstance(num1, int))      # True (bool是int的子类)

书写很大的数时，可使用下划线将其中的数字分组，使其更清晰易读（Java 7+ 也支持此特性）。

num1 = 1_000_000_000
print(num1)  # 1000000000

2.字符串类型 (String)

见后文详解。

3.容器类型 (Container)

• list (列表)：有序、可变序列。类似 Java ArrayList。
• tuple (元组)：有序、不可变序列。类似 Java 数组或 List.of()。
• set (集合)：无序、不重复集合。类似 Java HashSet。
• dict (字典)：键值对集合。类似 Java HashMap。

4.特殊类型

• None：表示空值。
  Java 对比：类似 Java 的 null。但 None 是一个单例对象（NoneType），不能像 Java 那样把 null 赋值给任意引用类型（虽然 Python 变量可以指向 None）。

5.可变性分类

• 不可变：Number, String, Tuple 创建后，其值不能被修改。如果尝试 “修改”，实际上是创建了一个新的对象，内存地址会发生变化。

# 1. 数字（Number）
a = 10
print(f"修改前a的值: {a}, 内存地址: {id(a)}")  # 比如地址是 140708467523296
a = a + 1  # 看似修改，实际是创建新对象
print(f"修改后a的值: {a}, 内存地址: {id(a)}")  # 地址变成 140708467523328（新地址）

• 可变：List, Dict, Set 创建后，其值可以被修改，且修改后内存地址保持不变（容器本身没换，只是内容变了）。

# 1. 列表（List）
lst = [1, 2, 3]
print(f"修改前lst的值: {lst}, 内存地址: {id(lst)}")  # 比如地址是 2205689748288
lst[0] = 100  # 直接修改列表元素
print(f"修改后lst的值: {lst}, 内存地址: {id(lst)}")  # 地址还是 2205689748288（不变）

示例

"""
    Python中的数据类型：
        数值
            整数
            浮点数
            布尔
            复数
        字符串
        容器
           列表[]
           元组()
           集合{}
           字典
        None
    通过type函数查看变量的类型
"""
num = 1
print(type(num))
num1 = 8.88
print(type(num1))
num2 = True
print(type(num2))
num3 = 1_000_000_000_000
print(type(num3))
print(num3)
# 布尔类型属于int的子类型
num4 = False
print(isinstance(num4,int))
print("------------------------------")

# 数值、字符串、元组属于不可变类型，列表、集合、字典属于可变类型
str = 'hello'
print(str)
print(id(str))
str = "python"
print(str)
print(id(str))
print("------------------------------")

# 声明一个列表
my_list = [1,2,3,4]
print(my_list)
print(id(my_list))
# 修改列表第一个位置的值
my_list[0] = 100
print(my_list)
print(id(my_list))
print("------------------------------")

# 声明一个函数
def hello_world():
    print("hello python")

result = hello_world()
print(result)

执行代码结果

<class 'int'>
<class 'float'>
<class 'bool'>
<class 'int'>
1000000000000
True
------------------------------
hello
2359696715968
python
2359694490720
------------------------------
[1, 2, 3, 4]
2359694594368
[100, 2, 3, 4]
2359694594368
------------------------------
hello python
None

字符串详解 (str)

字符串定义

用单引号 ’ 或双引号 " 括起来即可，两者可互相嵌套（避免引号冲突）：

str1 = 'This is a "string"'  # 单引号内嵌套双引号
str2 = "This is a 'string' too"  # 双引号内嵌套单引号
print(str1)  # 输出：This is a "string"
print(str2)  # 输出：This is a 'string' too

多行字符串

用三引号 “”"（或 ‘’'）包裹，可直接换行书写，无需额外转义：

Java 对比：类似 Java 13+ 的 Text Blocks (“”“…”“”)。

str1 = """hello world
HELLO WORLD
你好 世界"""  # 直接换行，保留格式
print(str1)
# 输出：
# hello world
# HELLO WORLD
# 你好 世界

转义字符

用于表示无法直接输入的特殊字符，核心常用转义符如下：

转义符	说明	示例	输出效果
\n	换行	print(“hello\nworld”)
\t	制表符	print(“name:\tTom”)	name: Tom
\	反斜杠	print(“C:\Python”)	C:\Python
’	单引号	print(‘I’m Tom’)	I’m Tom

字符串常用方法

字符串方法是对字符串做处理的核心操作，以下 4 个是日常最常用的，均基于基础数据类型，无需复杂语法：

1.split ()：拆分字符串（转成列表）

作用：按指定分隔符把字符串拆分成列表，默认按 “空格 / 换行 / 制表符” 拆分。
语法：字符串.split(分隔符, 拆分次数)（拆分次数可选）

# 示例1：按逗号拆分（处理输入/数据解析）
text = "苹果,香蕉,橙子"
result = text.split(",")  # 按逗号拆分
print(result)  # 输出：['苹果', '香蕉', '橙子']
​
# 示例2：默认按空格拆分
text2 = "hello world python"
result2 = text2.split()  # 不写分隔符，默认按空格拆
print(result2)  # 输出：['hello', 'world', 'python']
​
# 示例3：指定拆分次数（只拆1次）
text3 = "a-b-c-d"
result3 = text3.split("-", 1)  # 按-拆分，只拆1次
print(result3)  # 输出：['a', 'b-c-d']

2.join ()：拼接列表为字符串（split 的反向操作）

作用：用指定字符串把列表中的元素拼接成一个新字符串。
语法：分隔符.join(列表)

# 示例：把水果列表拼成“苹果|香蕉|橙子”
fruits = ['苹果', '香蕉', '橙子']
result = "|".join(fruits)  # 用|拼接列表元素
print(result)  # 输出：苹果|香蕉|橙子

# 示例2：拼接成无分隔符的字符串
chars = ['h', 'e', 'l', 'l', 'o']
result2 = "".join(chars)
print(result2)  # 输出：hello

3.strip ()：去除首尾空白 / 指定字符

作用：默认去除字符串首尾的空格、换行、制表符；也可指定去除首尾的字符。
语法：字符串.strip(指定字符)（指定字符可选）

# 示例1：去除首尾空格（处理用户输入超实用）
text = "  hello world  "
result = text.strip()
print(result)  # 输出：hello world（首尾空格没了）

# 示例2：去除首尾指定字符（比如首尾的#）
text2 = "##python##"
result2 = text2.strip("#")
print(result2)  # 输出：python

# 补充：lstrip()只去左边，rstrip()只去右边
print("  abc  ".lstrip())  # 输出：abc  （只去左边空格）
print("  abc  ".rstrip())  # 输出：  abc（只去右边空格）

4.replace ()：替换字符串中的指定内容

作用：把字符串中的某段内容替换成新内容，可指定替换次数。
语法：字符串.replace(旧内容, 新内容, 替换次数)（次数可选）

# 示例1：全部替换
text = "hello world, hello python"
result = text.replace("hello", "hi")  # 把所有hello换成hi
print(result)  # 输出：hi world, hi python

# 示例2：指定替换次数（只替换1次）
text2 = "a-b-a-b-a"
result2 = text2.replace("a", "x", 2)  # 只替换前2个a
print(result2)  # 输出：x-b-x-b-a

# 示例3：替换为空（相当于删除指定内容）
text3 = "123abc456"
result3 = text3.replace("abc", "")  # 删除abc
print(result3)  # 输出：123456

示例

# 使用双引号或单引号括起来的都属于字符串
from http.cookiejar import join_header_words

str = "hello python"
print(type(str))
str2 = 'hello world'
# 双引号字符串中可以嵌套单引号；单引号字符串中可以嵌套双引号
str3 = "hello 'python'"
str4 = 'hello "world"'
print(type(str4))
# 多行字符串，使用三个双引号或单引号（所见即所得）
str5 = """
    Hello World
    Hello Python
    Hello Java
    Hello C
"""
print(type(str5))
print(str5)
print("------------------------------")

# 转义字符
str6 = "hello\npython"
print(str6)
str7 = "I'am Tom"
print(str7)
str8 = 'I\'m Jerry'
print(str8)
print("------------------------------")

# split()02函数
str9 = "蔡徐坤,吴亦凡,王飞龙,李易峰,PGone,李小璐"
my_list = str9.split(",")
print(my_list)
print(type(my_list))
print("------------------------------")

# join()02函数
my_list2 = ["罗志祥","陶喆","文章","林丹","吴秀波"]
# 使用♂符号将列表中的数据连接起来
my_str = "/".join(my_list2)
print(my_str)
print("------------------------------")

# strip()02函数：去掉前后空格
my_str = "          "
print(my_str)
# 去除前后空格之后hello pytho
print(my_str.strip())
# 去除左边的空格
print(my_str.lstrip())
# 去除右边的空格
print(my_str.rstrip())
print("------------------------------")

# replace()02函数
my_str2 = "范冰冰,赵薇,户晨风"
print(my_str2.replace(",","-"))
print(my_str2.replace(",",""))
my_str3 = "hahaha python"
print(my_str3.replace("ha","hei",2))
print("------------------------------")

# 只截取前5个字符
test = "asdfasdfasdfasdfa"
print(test[:5])

执行代码结果

<class 'str'>
<class 'str'>
<class 'str'>

    Hello World
    Hello Python
    Hello Java
    Hello C

------------------------------
hello
python
I'am Tom
I'm Jerry
------------------------------
['蔡徐坤', '吴亦凡', '王飞龙', '李易峰', 'PGone', '李小璐']
<class 'list'>
------------------------------
罗志祥/陶喆/文章/林丹/吴秀波
------------------------------
     hello pytho     
hello pytho
hello pytho     
     hello pytho
------------------------------
范冰冰-赵薇-户晨风
范冰冰赵薇户晨风
heiheiha python
------------------------------
asdfa

数据类型转换

隐式转换

自动提升精度，如 int + float -> float。

num1 = 2
num2 = 3.0
print(num1 + num2)  # 5.0

特别的是，两个整数除法运算也是浮点

num1 = 9
num2 = 1
print(num1 / num2)  # 9.0

而整型和字符串相加会报错，此时Python无法进行隐式转换完成计算：

num1 = 123
str1 = "456"
print(num1 + str1)  # 报错

显式转换

1. 转整数（int ()）

规则：只能转纯数字字符串 / 浮点数 / 布尔值，浮点数转整数会直接去掉小数（不四舍五入）

# 示例
print(int("123"))    # 字符串转整数 → 123
print(int(3.99))     # 浮点数转整数 → 3
print(int(True))     # 布尔值True转整数 → 1
print(int(False))    # 布尔值False转整数 → 0

2.转字符串（str ()）

规则：所有类型都能转，直接变成对应字符串形式

# 示例
print(str(123))      # 整数转字符串 → "123"
print(str(3.14))     # 浮点数转字符串 → "3.14"
print(str(True))     # 布尔值转字符串 → "True"
print(str([1,2]))    # 列表转字符串 → "[1, 2]"

3.转布尔值（bool ()）

规则：0 / 空值 / 空容器为 False，其他都是 True

# 示例
print(bool(0))       # 0 → False
print(bool(123))     # 非0数字 → True
print(bool(""))      # 空字符串 → False
print(bool("abc"))   # 非空字符串 → True
print(bool([]))      # 空列表 → False
print(bool([1]))     # 非空列表 → True

编码与解码

encode(“utf-8”)：把 Python 的字符串（str）转成二进制字节（bytes）—— 接口传输、跨系统通信时，只能传输二进制数据，不能直接传字符串，这一步是为了让字符串 “能被传输”。

decode(“utf-8”)：把接口接收到的二进制字节（bytes）转回字符串（str）—— 拿到二进制数据后，只有转成字符串才能正常阅读、处理（比如解析接口返回的中文内容）。

text = "你好"
data = text.encode("utf-8") # 转为 bytes
print(data) # b'\xe4\xbd\xa0\xe5\xa5\xbd'
print(data.decode("utf-8")) # 转回 str

示例

# 隐式转换
num = 3
num2 = 3.3
# 整型和浮点型相加转换为浮点型
num3 = num + num2
print(num3)
print(type(num3))
print("------------------------------")

# 两个整型相除也会转换为浮点型
num4 = 10
num5 = 3
num6 = 10 / 3
print(num6)
print(type(num6))
print("------------------------------")

# 注意：在Python中整型和字符串不能相加，不会拼接字符串会报错
num7 = 88
str = "My Balance is"
# str2 = str + num7
# print(str2)
print("------------------------------")

# 显示转换
# 字符串转int，字符串必须是数值类型
my_str = "123"
my_str_to_int = int(my_str)
print(my_str_to_int)
print(type(my_str_to_int))
print("------------------------------")

# 浮点型转int，直接截取
my_float = 3.99
my_float_to_int = int(my_float)
print(my_float_to_int)
print(type(my_float_to_int))
print("------------------------------")

# 布尔转int
my_f = False
my_f_to_int = int(my_f)
print(my_f_to_int)
print(type(my_f_to_int))
print("------------------------------")

# 转布尔类型：0/空值/空容器为False，其他为True
my_num = 0
my_s = ""
my_l = []
my_num2 = 111
my_s2 = "hello"
my_l2 = [1,2,3]
my_num_to_bool = bool(my_num)
print(my_num_to_bool) # False
print(type(my_num_to_bool))
my_s_to_bool = bool(my_s)
print(my_s_to_bool) # False
print(type(my_s_to_bool))
my_l_to_bool = bool(my_l)
print(my_l_to_bool) # False
print(type(my_l_to_bool))
my_num2_to_bool = bool(my_num2)
print(my_num2_to_bool) #True
my_s2_to_bool = bool(my_s2)
print(my_s2_to_bool) # True
my_l2_to_bool = bool(my_l2)
print(my_l2_to_bool) # True
print("------------------------------")

# 编码
my_en = "快下课了"
my_by = my_en.encode("UTF-8")
print(my_by)
print(type(my_by))
print("------------------------------")

# 解码
my_en2 = my_by.decode("UTF-8")
print(my_en2)
print(type(my_en2))

执行响应结果

6.3
<class 'float'>
------------------------------
3.3333333333333335
<class 'float'>
------------------------------
------------------------------
123
<class 'int'>
------------------------------
3
<class 'int'>
------------------------------
0
<class 'int'>
------------------------------
False
<class 'bool'>
False
<class 'bool'>
False
<class 'bool'>
True
True
True
------------------------------
b'\xe5\xbf\xab\xe4\xb8\x8b\xe8\xaf\xbe\xe4\xba\x86'
<class 'bytes'>
------------------------------
快下课了
<class 'str'>

输入与输出

输入

获取用户在控制台的输入，相当于 Java 的 Scanner。

• 重要特性：input() 函数接收到的内容永远是字符串 (str)。
• 类型转换：如果需要数字，必须手动转换（如 int()）。

# 提示用户输入（阻塞式）
name = input("请输入姓名：") 
print("你好,", name)

# 接收数值（需转换）
# Java写法：int age = scanner.nextInt();
age_str = input("请输入年龄：")
age = int(age_str)  # 转换为整数
# 简写：age = int(input("请输入年龄："))

if age >= 18:
    print("成年人")
else:
    print("未成年")

输出 (Print)

将内容输出到控制台（Console），相当于 Java 的 System.out.println()。

1. 基础用法

print("hello world") # 自动换行

# 多参数输出（自动以空格分隔）
print("name:", "Tom", "age:", 18) 
# 输出：name: Tom age: 18

# 自定义分隔符与结尾
print("a", "b", "c", sep="-", end="!") 
print("next line")
# 输出：a-b-c!next line

2.格式化输出

2.1 % 占位符（基础老式写法）

核心用法：用%加指定字符表示占位类型，末尾用%拼接要填充的值（多个值需用元组）。

常用占位符：%s（字符串 / 万能）、%d（整数）、%f（浮点数）

# 基础示例
print("name=%s, age=%d" % ("Tom", 18))  # 输出：name=Tom, age=18

# 补充：浮点数格式化（保留2位小数）
print("身高=%.2f米" % 1.785)  # 输出：身高=1.79米（自动四舍五入）

# 补充：多个变量占位
name = "Jerry"
score = 95.5
print("姓名：%s，分数：%d" % (name, score))  # 输出：姓名：Jerry，分数：95

特点：兼容性好（适配老版本 Python），但写法繁琐，占位符和值容易对应错。

2.2 format 方法（通用写法）

核心用法：用{}占位，通过format()传值，支持按位置 / 按名称取值，更灵活。

# 基础示例（按位置）
print("name={}, age={}".format("Tom", 18))  # 输出：name=Tom, age=18
# 补充1：按索引指定顺序（解决值顺序错的问题）
print("age={1}, name={0}".format("Tom", 18))  # 输出：age=18, name=Tom
# 补充2：按名称取值（更易读）
print("name={n}, age={a}".format(n="Tom", a=18))  # 输出：name=Tom, age=18
# 补充3：浮点数保留2位小数
print("体重={:.2f}kg".format(65.892))  # 输出：体重=65.89kg

特点：比 % 占位符灵活，无需记占位符类型，但写法比 f-string 稍繁琐。

2.3 f-string（Python3.6 + 推荐写法）

核心用法：字符串前加f/F，{}内直接写变量 / 表达式，简洁高效。

# 基础示例
name = "Tom"
age = 18
print(f"name={name}, age={age}")  # 输出：name=Tom, age=18

# 补充1：直接写表达式（无需额外计算）
print(f"明年年龄：{age + 1}")  # 输出：明年年龄：19

# 补充2：浮点数格式化（保留2位，加千分位）
salary = 12345.6789
print(f"月薪：{salary:,.2f}")  # 输出：月薪：12,345.68
print(f"月薪：{salary:.2f}") # 输出：月薪：12345.68

# 补充3：{变量=} 快速打印变量名+值（调试超实用）
print(f"{name=}, {age=}")  # 输出：name='Tom', age=18

特点：写法最简洁、执行效率最高，支持表达式和灵活的格式控制，是日常开发首选。

运算符详解

算术运算符

用于数值的加减乘除、取余、幂运算等，是最基础的运算符。

运算符	含义	示例 (a=7, b=3)	结果	Java 对比
+	加法	a + b	10	同 Java
-	减法	a - b	4	同 Java
*	乘法	a * b	21	同 Java
/	真除法	a / b	2.333…	Java整数相除结果是整数，Python永远是浮点
//	整除（地板除）	a // b	2	等价于 Java 的 / (整数相除)
%	取余（模运算）	a % b	1	同 Java
**	幂运算	a ** b	343（7³）	等价于 Java Math.pow(a, b)

a = 7
b = 3
print(a / b)   # 2.333... (注意：无论是否整除，结果都是float)
print(a // b)  # 2        (保留整数部分，向下取整)
print(a % b)   # 1        (余数)
print(a ** b)  # 343      (7的3次方)

赋值运算符

用于给变量赋值，复合赋值运算符（+=/-=等）可简化 “运算 + 赋值” 操作。

基础运算符	复合运算符	示例	等价写法
=	-	x = 5	-
=	+=	x += 3	x = x + 3
=	-=	x -= 3	x = x - 3
=	*=	x *= 3	x = x * 3
=	/=	x /= 3	x = x / 3
=	//=	x //= 3	x = x // 3

注意：Python 不支持 Java 的 ++ / -- 自增自减运算符（i++ 是非法的），请使用 i += 1。

海象运算符 (:=)：Python 3.8+ 新增，核心优势是 “在表达式内部赋值”，避免重复计算。

# 常规写法：先计算长度，再判断
text = "hello"
length = len(text)
if length > 3:
    print(f"长度是 {length}")

# 海象运算符写法：一步完成赋值+判断
if (length := len(text)) > 3:
    print(f"长度是 {length}")  # 输出：长度是 5
print("="*30)

# 另一个实用场景：循环中减少重复调用
nums = [1,2,3,4]
while (n := len(nums)) > 0:
    print(f"当前列表长度：{n}")
    nums.pop()  # 每次删除最后一个元素

比较运算符

用于比较两个值的大小 / 是否相等，返回结果永远是布尔值（True/False）。

print(3 > 2)     # True
print(3 < 2)     # False
print(3 == 3)    # True
print(3 != 3)    # False

# 链式比较（Python 特有，Java 不支持）
age = 20
print(18 <= age < 60)  # True，等价于 age>=18 and age<60
# Java 写法： if (age >= 18 && age < 60)

4.4 逻辑运算符

用于组合多个布尔条件，核心是and（与）、or（或）、not（非），具有短路特性（提升执行效率）。

运算符	规则	Java 对比	短路特性
and	所有条件为 True，结果才为 True	&&	第一个条件为 False，直接返回 False
or	任意一个条件为 True，结果就为 True	||	第一个条件为 True，直接返回 True
not	取反（True 变 False，False 变 True）	!	无短路特性

age = 20
# and：两个条件都满足才为True
print(age >= 18 and age < 60)  # True
# or：满足一个就为True
print(age < 18 or age > 60)    # False
# not：取反
print(not (age < 18))          # True

# 短路特性示例（第二个表达式不会执行）
print(False and (1/0))  # 不会报错，因为False and 直接返回False
print(True or (1/0))    # 不会报错，因为True or 直接返回True

4.5 成员运算符

用于判断 “元素是否在容器中”，核心是in（存在）、not in（不存在），支持字符串、列表、元组、字典等。

Java 对比：

• 字符串：等价于 str.contains("sub")
• 列表/集合：等价于 list.contains(obj)
• 字典：等价于 map.containsKey(key)

# 字符串中判断子串
text = "hello world"
print("hello" in text)     # True
print("hi" not in text)    # True

# 列表/元组中判断元素
lst = [1, 2, 3]
print(1 in lst)            # True
print(4 not in lst)        # True

# 字典中默认判断key（不是value）
dic = {"name": "Tom", "age": 18}
print("name" in dic)       # True
print("Tom" in dic)        # False（判断value需用 dic.values()）

4.6 身份运算符

用于判断 “两个变量是否指向同一个内存地址”，核心是is、is not。

Java 核心差异（非常重要）：

• Python is ≈ Java ==：比较内存地址（Reference Equality）。
• Python == ≈ Java equals()：比较值（Value Equality）。

绝大多数情况下（判断数值、字符串内容），请使用 ==。只有判断 None 时推荐使用 is。

# 示例1：小整数池（Python优化，-5~256的整数共用地址）
x = 10
y = 10
print(x == y)    # True（值相等）
print(x is y)    # True（地址相同，类似 Java Integer 缓存池）

# 示例2：大整数（超出小整数池，地址不同）
a = 257
b = 257
print(a == b)    # True（值相等）
print(id(a))     # 1745371508176
print(id(b))     # 1745371508176
print(a is b)    # True

# 示例3：None的判断（推荐用is）
x = None
print(x is None)      # True（标准写法）
print(x == None)      # 不推荐
print(x is not None)  # False

4.7 运算符优先级

当一个表达式中有多个运算符时，Python 会按优先级依次计算（优先级高的先算），优先级从高到低核心顺序：

**`（幂） > `* / % //`（乘除取余整除） > `+ -`（加减） > `> < >= <= == !=`（比较） > `not` > `and` > `or

# 示例：按优先级计算
result = 2 + 3 * 4 **2  # 先算4²=16 → 再算3×16=48 → 最后算2+48=50
print(result)  # 50

# 技巧：不确定优先级时，用()括号强制改变顺序（更易读）
result = (2 + 3) * (4 **2)  # 先算2+3=5、4²=16 → 再算5×16=80
print(result)  # 80

---