Python基础语法入门

作者：没有四次元口袋的蓝胖

日期：2026-09-18

标签：Python, 基础语法

Python基础语法入门

从Java转Python，最先需要适应的就是语法层面的差异。Python的哲学是"简洁、优雅、可读性强"，很多在Java里需要一大堆模板代码才能完成的事情，Python几行就搞定了。这篇笔记覆盖面试和实际编码中最基础也最高频的语法点，每个知识点都配有Java对比代码，帮你快速建立映射关系。

核心掌握：动态类型、缩进代码块、字符串拼接、真假值判断、条件与循环、match语句。

一、动态类型

1.1 什么是动态类型

Python是动态类型语言 ，变量不需要声明类型，赋值即创建。变量的类型由它所引用的值决定，而不是变量本身。这和Java的静态强类型形成了鲜明对比------在Java中，你必须显式声明每个变量的类型，而且编译期就会进行类型检查。

python 复制代码

# Python：不需要声明类型，直接赋值
name = "蓝胖"          # 字符串，解释器自动推断为 str
age = 22               # 整数，自动推断为 int
score = 89.5           # 浮点数，自动推断为 float
is_student = True      # 布尔值，自动推断为 bool

# 同一个变量可以在不同时刻指向不同类型的值
x = 100                # 现在是 int
x = "hello"            # 现在变成 str 了，完全合法
x = [1, 2, 3]         # 现在变成 list 了，也没问题

java 复制代码

// Java：必须声明类型，且类型固定
String name = "蓝胖";
int age = 22;
double score = 89.5;
boolean isStudent = true;

// String x = "hello";  // 如果声明为String，就不能赋int值
// 不同类型需要不同变量，或者使用Object（但失去类型安全）

1.2 类型检查

虽然Python是动态类型，但你可以用 type() 和 isinstance() 在运行时检查类型：

python 复制代码

x = 42
print(type(x))           # <class 'int'>

x = "hello"
print(type(x))           # <class 'str'>

# isinstance 检查是否属于某个类型（支持继承关系）
print(isinstance(42, int))          # True
print(isinstance("hi", (str, int))) # True，可以是多个类型之一

1.3 常见坑点/面试注意点

动态类型 ≠ 没有类型：Python有类型，只是类型绑定在值上而非变量上。面试时别说"Python没有类型"。
不要用Java思维写Python ：不要给每个变量都加类型注释，Python的优雅就在于简洁。当然，可以用Type Hint做类型提示（name: str = "蓝胖"），但这不是强制的。
type() vs isinstance() ：isinstance() 考虑继承关系，type() 不考虑。面试问到类型判断时优先用 isinstance()。

二、缩进代替花括号

2.1 缩进即语法

Python用**缩进（通常4个空格）**来表示代码块，而Java用花括号 {}。这不是风格选择，而是语法强制------缩进不对直接报 IndentationError。

python 复制代码

# Python：缩进表示代码块
if score >= 90:
    grade = "A"
    print("优秀")       # 这行在 if 块内
elif score >= 60:
    grade = "B"
    print("及格")
else:
    grade = "C"
    print("不及格")
print("成绩评定完毕")     # 这行在 if 块外，无论什么条件都会执行

java 复制代码

// Java：花括号表示代码块
if (score >= 90) {
    grade = "A";
    System.out.println("优秀");
} else if (score >= 60) {
    grade = "B";
    System.out.println("及格");
} else {
    grade = "C";
    System.out.println("不及格");
}
System.out.println("成绩评定完毕");

2.2 嵌套缩进

python 复制代码

for i in range(3):
    for j in range(3):
        if i == j:
            print(f"对角线: ({i}, {j})")
        # 这里4个空格一层，绝对不能混用Tab和空格

2.3 常见坑点/面试注意点

Tab和空格混用是新手最常犯的错误。Python 3 直接报错，Python 2 更阴险------不报错但逻辑错。IDE一般会自动处理，但面试时手写代码要特别注意。
PEP 8 规范要求4个空格，不要用Tab，也不要用2个空格。
一行写多个语句 可以用分号 ;，但不推荐，会降低可读性。

三、字符串与f-string拼接

3.1 f-string（Python 3.6+）

f-string是Python最推荐的字符串格式化方式，直接在字符串内嵌入表达式，简洁且高效。

python 复制代码

name = "蓝胖"
age = 22

# f-string：最推荐的方式
greeting = f"我叫{name}，今年{age}岁"
print(greeting)              # 我叫蓝胖，今年22岁

# 支持表达式
print(f"明年我{age + 1}岁")    # 明年我23岁
print(f"名字大写：{name.upper()}")  # 名字大写：蓝胖（注意中文无变化）
print(f"{'hello':>10}")        # 右对齐，宽度10：     hello

3.2 其他格式化方式

python 复制代码

name = "蓝胖"
age = 22

# % 格式化（老式，了解即可）
s1 = "我叫%s，今年%d岁" % (name, age)

# .format() 方法（Python 3.0+，f-string之前主流）
s2 = "我叫{}，今年{}岁".format(name, age)
s3 = "我叫{0}，今年{1}岁".format(name, age)

# f-string（最推荐）
s4 = f"我叫{name}，今年{age}岁"

3.3 对比Java的字符串拼接

java 复制代码

// Java：字符串拼接方式
String s1 = "我叫" + name + "，今年" + age + "岁";           // + 拼接
String s2 = String.format("我叫%s，今年%d岁", name, age);    // printf风格
String s3 = "我叫%s，今年%d岁".formatted(name, age);         // Java 15+ 文本块

3.4 常见坑点/面试注意点

f-string中的 f 是小写 ，大写 F 也合法但不常见。
f-string在运行时求值 ，不是编译时常量。f"{'hello'}" 中的表达式每次都会执行。
反斜杠不能直接出现在f-string的表达式部分（Python 3.12之前）。需要换行或拼接处理。
面试常问 ：f-string 比 % 和 .format() 更快，因为它在运行时直接编译为字节码。

四、None与空值

4.1 None = Java的null

Python用 None 表示"没有值"，等价于Java的 null。注意首字母大写，这是Python的命名惯例（和 True、False 一样）。

python 复制代码

result = None          # 表示"没有值"
print(result is None)  # True，判断None必须用 is，不要用 ==

# None 是 NoneType 类型的唯一实例
print(type(None))      # <class 'NoneType'>

java 复制代码

// Java 对比
Object result = null;
System.out.println(result == null);  // Java用 == 判断null

4.2 None的常见使用场景

python 复制代码

# 1. 函数没有return时默认返回None
def say_hello():
    print("Hello")

result = say_hello()   # 打印了Hello，但result是None

# 2. 默认参数值
def greet(name=None):
    if name is None:
        name = "陌生人"
    print(f"你好，{name}")

greet()         # 你好，陌生人
greet("蓝胖")   # 你好，蓝胖

# 3. 作为占位符
data = None     # 稍后赋值

4.3 常见坑点/面试注意点

判断None必须用 is，不要用 == ：x is None 是Pythonic写法，x == None 虽然也能工作但违反PEP 8规范，面试时会被扣分。
None不是False ：None 和 False 不同。None 是 NoneType 的唯一实例，False 是 bool 类型。但在布尔上下文中，None 被视为 False。
默认参数不要用 [] 或 {} ：这是一个经典陷阱（后面数据结构篇会详细讲），用 None 代替更安全。

五、运算符

5.1 整除运算符 `//`

Python有两个除法运算符：/ 做浮点除法，// 做整数除法（向下取整）。

python 复制代码

# / 浮点除法（永远返回float）
print(10 / 3)     # 3.3333333333333335
print(10 / 2)     # 5.0，注意是5.0不是5

# // 整除（向下取整）
print(10 // 3)    # 3
print(10 // 2)    # 5
print(-10 // 3)   # -4，注意！向下取整，不是截断

# 对比Java
# Java的 / 对整数做截断除法：10/3=3，-10/3=-3
# Python的 // 做向下取整：10//3=3，-10//3=-4
# 这个差异面试常考！

5.2 幂运算符 `**`

python 复制代码

print(2 ** 10)    # 1024，2的10次方
print(9 ** 0.5)   # 3.0，9的平方根

5.3 逻辑运算符

Python用单词 and、or、not 代替了Java的符号 &&、||、!，可读性更强。

Python	Java	含义
`and`	`&&`	逻辑与
`or`	`
`not`	`!`	逻辑非

python 复制代码

# Python
x = 10
print(x > 5 and x < 20)    # True
print(x > 20 or x < 15)    # True
print(not x > 20)           # True

java 复制代码

// Java
int x = 10;
System.out.println(x > 5 && x < 20);   // true
System.out.println(x > 20 || x < 15);  // true
System.out.println(!(x > 20));          // true

5.4 逻辑运算符的返回值

这是一个很多Java转Python的人会忽略的点：Python的 and/or 返回的不是 True/False，而是参与运算的操作数之一。

python 复制代码

# and 返回第一个为False的值，如果都为True返回最后一个
print(3 and 5)       # 5（3为真，继续，5为真，返回5）
print(0 and 5)       # 0（0为假，直接返回0）
print(3 and 0)       # 0（3为真，继续，0为假，返回0）

# or 返回第一个为True的值，如果都为False返回最后一个
print(0 or 5)        # 5（0为假，继续，5为真，返回5）
print(3 or 5)        # 3（3为真，直接返回3）
print(0 or "")       # ""（0为假，继续，""为假，返回最后一个"")

# 实用技巧：用 or 设置默认值
name = user_input or "默认用户名"    # 如果user_input为空字符串，使用默认值

5.5 常见坑点/面试注意点

// 对负数的处理 ：-7 // 2 = -4（向下取整），而Java的 -7 / 2 = -3（向零截断）。面试高频坑点。
and/or 返回操作数而非布尔值：这在Java中不可能发生，需要适应。
短路求值 ：Python和Java一样有短路机制，and 遇到假值停止，or 遇到真值停止。

六、真假值判断

6.1 哪些值是False

Python中，以下值在布尔上下文中被视为 False（称为"falsy"值）：

python 复制代码

# 以下全部为 False
False       # 布尔值False
0           # 整数零
0.0         # 浮点零
""          # 空字符串
None        # None
[]          # 空列表
{}          # 空字典
()          # 空元组
set()       # 空集合

# 其他所有值都是 True
# 包括：非零数字、非空字符串、非空容器、True

java 复制代码

// Java 对比：只有 boolean 的 false 是假的
// Java 中 0、""、null 不能直接用在 if 条件里
// if (0) {}      // 编译错误！
// if ("") {}     // 编译错误！
// if (null) {}   // 编译错误！

6.2 实际应用

python 复制代码

# Pythonic写法：直接判断容器是否为空
names = []
if not names:             # 等价于 if len(names) == 0
    print("列表为空")

text = "hello"
if text:                  # 等价于 if len(text) > 0 或 if text != ""
    print("文本非空")

# Java写法（对比）
# if (names.isEmpty()) { }    // Java必须调方法
# if (!text.isEmpty()) { }

6.3 常见坑点/面试注意点

None 不是 0，不是 ""，不是 False ：虽然它们在布尔上下文中都是 False，但 None == False 返回 False，None == 0 也返回 False。判断None必须用 is None。
空列表 [] 是 False，但 [0] 是 True：只要有元素就是 True，不管元素本身是什么。
面试陷阱 ：bool("") 是 False，bool(" ") 是 True（空格也是字符）。

七、条件语句

7.1 if-elif-else

python 复制代码

score = 85

if score >= 90:
    grade = "A"
elif score >= 80:       # 注意：是 elif，不是 else if
    grade = "B"
elif score >= 70:
    grade = "C"
elif score >= 60:
    grade = "D"
else:
    grade = "F"

print(f"成绩等级: {grade}")  # 成绩等级: B

java 复制代码

// Java 对比
if (score >= 90) {
    grade = "A";
} else if (score >= 80) {   // Java 用 else if
    grade = "B";
} else if (score >= 70) {
    grade = "C";
} else {
    grade = "F";
}

7.2 三元表达式

Python的三元表达式语法是 值1 if 条件 else 值2，和Java的 条件 ? 值1 : 值2 语义相同但语法顺序不同。

python 复制代码

# Python 三元表达式
age = 20
status = "成年" if age >= 18 else "未成年"
print(status)          # 成年

# 等价于
if age >= 18:
    status = "成年"
else:
    status = "未成年"

# 嵌套三元（不推荐，可读性差）
level = "高" if age >= 60 else ("中" if age >= 18 else "低")

java 复制代码

// Java 三元表达式
int age = 20;
String status = age >= 18 ? "成年" : "未成年";
// 注意顺序差异：
// Python: "成年" if age >= 18 else "未成年"
// Java:   age >= 18 ? "成年" : "未成年"
// Python 读起来更像自然语言，Java 条件在前

7.3 常见坑点/面试注意点

elif 不是 else if：拼写错误是新手常见bug。
Python没有switch语句（3.10之前） ：只能用if-elif-else链。3.10引入了 match。
三元表达式的顺序 ：Python是 True值 if 条件 else False值，不是 条件 ? True值 : False值。面试手写代码时别搞反。
Python的条件表达式不支持链式比较 ：不能写 x if a < b < c else y 这种（实际上Python支持 a < b < c 的链式比较，但不推荐在三元表达式里用）。

八、循环

8.1 for循环 + range()

Python的 for 循环是增强for循环 （类似Java的for-each），遍历任何可迭代对象。配合 range() 可以实现传统for循环的效果。

python 复制代码

# 遍历列表（类似Java的for-each）
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(fruit)

java 复制代码

// Java for-each
List<String> fruits = List.of("apple", "banana", "cherry");
for (String fruit : fruits) {
    System.out.println(fruit);
}

python 复制代码

# range() 的三种用法
for i in range(5):          # 0, 1, 2, 3, 4
    print(i)

for i in range(2, 8):       # 2, 3, 4, 5, 6, 7（左闭右开）
    print(i)

for i in range(0, 10, 2):   # 0, 2, 4, 6, 8（步长为2）
    print(i)

# 等价于Java的传统for循环
# for (int i = 0; i < 5; i++) { ... }
# 等价于 range(5)

# 带索引遍历（类似Java的for(int i=0; i<list.size(); i++)）
fruits = ["apple", "banana", "cherry"]
for i, fruit in enumerate(fruits):    # enumerate 同时获取索引和值
    print(f"{i}: {fruit}")

# 倒序遍历
for i in range(9, -1, -1):  # 9, 8, 7, ..., 1, 0
    print(i)

8.2 while循环

python 复制代码

# 基本while循环
count = 0
while count < 5:
    print(count)
    count += 1        # Python没有 ++ 运算符！

# do...while 的效果（Python没有do-while，用while+break模拟）
while True:
    user_input = input("输入q退出: ")
    if user_input == "q":
        break

8.3 循环控制

python 复制代码

# break 和 continue（和Java一样）
for i in range(10):
    if i == 3:
        continue      # 跳过3
    if i == 7:
        break         # 到7停止
    print(i)          # 输出：0 1 2 4 5 6

# for...else（Python特有！循环正常结束（没有break）时执行else）
for i in range(5):
    if i == 10:
        break
else:
    print("循环正常结束")    # 会执行，因为没有break

# 实用场景：搜索
for n in [2, 3, 5, 7, 8, 9]:
    if n % 2 == 0:
        print(f"找到偶数: {n}")
        break
else:
    print("没有找到偶数")    # 不会执行，因为break了

8.4 常见坑点/面试注意点

Python没有 ++ 和 -- 运算符 ：必须写 i += 1，不能写 i++。
range() 是左闭右开 ：range(5) 生成 0~4，不包含5。和Java的 i < 5 等价。
for...else 语法：else块在循环没有被break中断时执行。这个语法很Pythonic但Java程序员容易忽略。
enumerate() 很好用 ：需要索引时用它，不要用 range(len(list))。

九、match语句（Python 3.10+）

9.1 模式匹配

match 是Python 3.10引入的结构化模式匹配，类似Java的 switch 但功能强大得多。

python 复制代码

# 基本用法
status_code = 404

match status_code:
    case 200:
        print("OK")
    case 301:
        print("Moved Permanently")
    case 404:
        print("Not Found")       # 匹配这里
    case 500:
        print("Internal Server Error")
    case _:                      # _ 相当于 default
        print("Unknown Status")

java 复制代码

// Java switch 对比
int statusCode = 404;
switch (statusCode) {
    case 200:
        System.out.println("OK");
        break;              // Java需要break防止fall-through
    case 301:
        System.out.println("Moved Permanently");
        break;
    case 404:
        System.out.println("Not Found");
        break;
    default:
        System.out.println("Unknown Status");
}

9.2 关键差异：无fall-through

Python的 match 没有贯穿（fall-through） ，每个case匹配后自动停止，不需要 break。

python 复制代码

# Python：不需要break，匹配后自动停止
command = "start"
match command:
    case "start":
        print("启动")
        # 不会继续执行下面的case
    case "stop":
        print("停止")
    case _:
        print("未知命令")

java 复制代码

// Java：需要break，否则会fall-through
switch (command) {
    case "start":
        System.out.println("启动");
        break;    // 不加break会继续执行"stop"的逻辑！
    case "stop":
        System.out.println("停止");
        break;
}

9.3 高级模式匹配

python 复制代码

# 匹配多个值
point = (0, 5)
match point:
    case (0, 0):
        print("原点")
    case (0, y):            # 解构匹配，绑定变量y
        print(f"在Y轴上，y={y}")
    case (x, 0):
        print(f"在X轴上，x={x}")
    case (x, y):
        print(f"点({x}, {y})")

# 匹配数据结构
def process_command(cmd):
    match cmd.split():
        case ["quit"]:
            print("退出程序")
        case ["go", direction]:
            print(f"向{direction}方向移动")
        case ["pick", "up", item]:
            print(f"捡起{item}")
        case _:
            print("未知命令")

process_command("go north")    # 向北方向移动
process_command("pick up sword")  # 捡起sword

9.4 常见坑点/面试注意点

match是Python 3.10+的特性：确认运行环境版本再使用，面试时要说明版本要求。
没有fall-through：这是和Java switch最大的区别。
_ 是通配符 ：类似Java switch的 default，匹配任何值。
模式匹配不仅仅是值比较 ：还支持解构、守卫条件（case x if x > 0）、类模式等高级功能，比Java switch强大得多。

🗺️ 思维导图速览

复制代码

Python基础语法
├── 动态类型
│   ├── 变量无需声明类型
│   ├── type() / isinstance() 检查类型
│   └── 类型绑定在值上，不在变量上
├── 缩进代码块
│   ├── 4个空格表示代码块（代替{}）
│   ├── 严禁Tab和空格混用
│   └── 缩进错误 → IndentationError
├── 字符串拼接
│   ├── f-string（推荐）：f"Hello {name}"
│   ├── .format()（兼容）
│   └── 对比Java: String.format()
├── None（= Java null）
│   ├── 判断用 is None（不是 ==）
│   └── NoneType的唯一实例
├── 运算符
│   ├── // 整除（向下取整，负数注意！）
│   ├── ** 幂运算
│   ├── and/or/not（= &&/||/!）
│   └── and/or 返回操作数，非布尔值
├── 真假值判断
│   ├── falsy: 0/""/None/[]/{}/()
│   ├── 其他都为True
│   └── if not list: 判断空列表
├── 条件语句
│   ├── if-elif-else（注意elif拼写）
│   ├── 三元：x if cond else y
│   └── 对比Java: cond ? x : y
├── 循环
│   ├── for + range()（左闭右开）
│   ├── enumerate() 带索引遍历
│   ├── while（无++/--运算符）
│   ├── for...else（无break时执行else）
│   └── break/continue
└── match（3.10+）
    ├── 类似Java switch
    ├── 无fall-through（不需break）
    ├── _ 通配符（= default）
    └── 支持解构匹配和模式绑定

📝 写在最后

学习建议

动手敲每一个例子：光看不练等于没学，特别是缩进和f-string的语法。
建立Java→Python的映射表：把常用语法对应关系记下来，写代码时直接翻译。
注意"Pythonic"写法 ：比如判断空列表用 if not list 而不是 if len(list) == 0，面试时这些细节能加分。
重点关注差异点 ：动态类型、整除运算符对负数的处理、and/or 返回值、for...else------这些是Java转Python最容易踩的坑。

面试高频问题速答

Q：Python和Java的主要语法差异？

动态类型（变量不需声明类型）、缩进代替花括号、f-string字符串格式化、and/or/not逻辑运算符、elif代替else if、三元表达式顺序不同（x if cond else y）、没有++/--运算符、//整除运算符（负数向下取整）、for...else语法、3.10+的match语句。

Q：Python的 and/or 和Java的 &&/|| 有什么区别？

Java的逻辑运算符返回布尔值，Python的 and/or 返回操作数本身。and 返回第一个为假的操作数（都为真则返回最后一个），or 返回第一个为真的操作数（都为假则返回最后一个）。这个特性常用于设置默认值：name = user_input or "默认"。

Q：-7 // 2 在Python和Java中结果分别是什么？

Python：-7 // 2 = -4（向下取整），Java：-7 / 2 = -3（向零截断）。Python的整除总是向负无穷方向取整，Java的整数除法向零取整。

Python基础语法入门