Python 是一种语法简洁、容易入门的编程语言。本篇从零开始介绍 Python 的基础知识，包括变量、注释、数据类型、字符串、数字运算、赋值运算、函数、作用域、比较运算、条件判断以及布尔逻辑。

学完本篇后，你应该能够看懂大部分基础 Python 代码，并理解：

• 数据保存在哪里？
• 不同类型的数据有什么区别？
• 字符串如何处理？
• 数字如何计算？
• 函数如何使用？
• if 如何做判断？
• and、or、not 到底是什么意思？

什么是 Python？

Python 是一种通用的编程语言。

它最大的特点之一就是：

语法比较简洁，非常适合初学者入门。

例如，用 Python 输出一句话，只需要：

print("Hello World")

程序就会输出：

Hello World

相比一些语法更加复杂的编程语言，Python 通常可以用更少的代码完成同样的任务。

Python 可以用来做什么？

Python 并不是只能用来写简单的小程序。

它可以应用在很多领域。

因此，Python 可以简单理解为：

一种用途非常广泛的编程工具。

什么是变量（Variable）？

在程序中，我们经常需要保存一些数据。

例如：

姓名：John Doe
年龄：25

如果希望程序记住这些数据，就可以使用：

变量（Variable）

变量可以理解成一个：

用来保存数据的名字。

例如：

name = "John Doe"
age = 25

可以理解成：

name
 ↓
"John Doe"

age
 ↓
25

以后就可以通过变量名找到这些数据。

例如：

print(name)
print(age)

输出：

John Doe
25

如何创建变量？

Python 创建变量非常简单：

变量名 = 数据

例如：

name = "Alice"
age = 18
score = 95.5
is_student = True

这里：

其中：

=

叫做：

赋值运算符（Assignment Operator）

它的作用不是“判断是否相等”，而是：

把右边的数据保存到左边的变量中。

例如：

age = 18

可以理解成：

18
 ↓
保存到
 ↓
age

Python 变量不需要提前声明类型

Python 是一种：

动态类型语言（Dynamically Typed Language）

简单来说：

创建变量时，不需要提前告诉 Python 这个变量是什么类型。

例如：

age = 18
name = "Alice"
score = 95.5

Python 会根据保存的数据自动判断类型。

例如：

age = 18

Python 会知道：

age 是 int 类型

而：

name = "Alice"

Python 会知道：

name 是 str 类型

所以不需要写成类似：

int age = 18

Python 直接写：

age = 18

即可。

变量命名规则

变量名称并不是随便写的。

Python 对变量名有一定要求。

规则一：不能以数字开头

正确：

age = 18
name1 = "Alice"

错误：

1name = "Alice"

因为变量名不能以数字开头。

规则二：只能使用字母、数字和下划线

例如：

student_name = "Tom"
student_age = 18

是合法的。

规则三：变量名区分大小写

下面三个变量是不同的变量：

age = 18
Age = 20
AGE = 30

Python 会把它们看成三个不同的名字。

因此：

age
Age
AGE

并不相同。

规则四：不能使用 Python 关键字

Python 中有一些特殊单词已经被系统使用。

例如：

if
else
for
while
class
def
return
True
False
None

这些叫：

关键字（Keyword）

不能把它们直接当作普通变量名。

例如：

class = 10

就是错误的。

推荐的变量命名方式

如果一个变量由多个单词组成，通常使用：

snake_case（蛇形命名法）

也就是：

单词之间使用下划线 _ 连接。

例如：

student_name = "Alice"
student_age = 18
total_score = 95

不要写成：

studentname
student-name
student name

推荐：

student_name

什么是注释（Comment）？

程序代码是给计算机执行的。

但是有时候，我们还需要给：

人类程序员

留下说明。

这就是：

注释（Comment）

注释的内容不会被 Python 当作普通代码执行。

单行注释

Python 使用：

#

表示单行注释。

例如：

# 这是一个注释

name = "Alice"

也可以写在代码后面：

age = 18  # 保存学生年龄

为什么需要注释？

例如：

score = price * 0.8

如果代码很多，过一段时间后可能会忘记：

0.8 是什么意思？

可以写：

score = price * 0.8  # 打八折

这样以后自己或者其他程序员就更容易看懂。

注意：三引号不是严格意义上的注释

很多初学者会看到：

"""
这是一大段文字
"""

然后认为：

这是多行注释。

严格来说并不是。

""" """ 创建的是一个：

多行字符串（Multi-line String）

例如：

message = """
Hello
Python
"""

这里它是真正的字符串。

如果只是单独写：

"""
这段文字没有赋值
"""

Python 通常不会产生可见效果，因此经常被拿来临时写大段说明。

但是学习 Python 时最好知道：

Python 没有专门的多行注释语法。

如果是正式代码注释，通常还是使用：

# 第一行注释
# 第二行注释
# 第三行注释

print() 函数

print() 是 Python 最常见的内置函数之一。

它的作用是：

把内容输出到终端。

例如：

print("Hello World")

输出：

Hello World

也可以输出变量：

name = "Alice"

print(name)

输出：

Alice

还可以同时输出多个内容：

name = "Alice"
age = 18

print(name, age)

输出：

Alice 18

Python 中的常见数据类型

程序中的数据并不是完全一样的。

例如：

18
3.14
"Hello"
True

它们分别属于不同的数据类型。

可以把：

数据类型（Data Type）

理解成：

告诉 Python：“这个数据属于哪一类。”

常见数据类型速查表

整数（int）

int 是：

Integer（整数）

的缩写。

整数就是：

没有小数部分的数字。

例如：

age = 18
score = 100
temperature = -5

print(age)
print(score)
print(temperature)

浮点数（float）

float 表示：

Floating-point Number（浮点数）

简单理解就是：

带有小数的数字。

例如：

price = 19.99
height = 175.5

可以使用：

print(price)

输出：

19.99

字符串（str）

str 是：

String（字符串）

的缩写。

字符串就是：

一串文字或字符。

例如：

name = "Alice"
message = "Hello World"

字符串通常使用：

"双引号"

或者：

'单引号'

包起来。

布尔值（bool）

bool 是：

Boolean（布尔值）

的缩写。

它只有两个值：

True
False

分别表示：

True  → 真
False → 假

例如：

is_student = True
is_admin = False

布尔值经常用于：

条件判断。

列表（list）

列表用于保存：

一组有顺序的数据。

例如：

my_list = [22, "Hello World", 3.14, True]

print(my_list)

输出：

[22, 'Hello World', 3.14, True]

列表可以同时保存不同类型的数据。

例如：

students = ["Alice", "Bob", "Tom"]

元组（tuple）

元组也是：

有顺序的数据集合。

例如：

my_tuple = (7, 5, 8)

print(my_tuple)

输出：

(7, 5, 8)

元组与列表的一个重要区别是：

元组创建后，不能直接修改其中的元素。

例如：

my_tuple = (1, 2, 3)

可以理解成：

固定的一组数据

集合（set）

集合用于保存：

不重复的数据。

例如：

my_set = {7, 5, 8}

print(my_set)

集合中的元素没有像列表那样固定的索引顺序，因此不要依赖它的输出顺序。

集合的一个重要特点是：

my_set = {1, 2, 2, 3, 3}

print(my_set)

结果只会保留不重复的元素。

字典（dict）

字典用于保存：

键（Key）和值（Value）之间的对应关系。

例如：

student = {
    "name": "Alice",
    "age": 18
}

可以理解成：

"name" → "Alice"
"age"  → 18

这种：

Key → Value

的结构叫：

键值对（Key-Value Pair）

range 类型

range() 可以表示：

一段连续的整数范围。

例如：

numbers = range(5)

print(numbers)

输出：

range(0, 5)

它表示：

0
1
2
3
4

注意：

range(5) 包含 0，但不包含 5。

range() 经常和循环一起使用。

None

None 是 Python 中一个特殊的值。

它通常表示：

没有值、空值或者暂时没有结果。

例如：

result = None

print(result)

输出：

None

注意：

None

并不等于：

0

也不等于：

""

它是 Python 专门表示“没有值”的特殊对象。

可变类型和不可变类型

这是 Python 中一个比较重要的概念。

数据类型大致可以分为：

不可变（Immutable）
可变（Mutable）

什么是不可变类型？

不可变（Immutable）

可以简单理解为：

对象创建后，其内容不能直接修改。

常见不可变类型包括：

• int
• float
• bool
• str
• tuple
• range
• NoneType

例如：

name = "Alice"

字符串本身不能直接修改。

如果：

name = "Bob"

这并不是把原来的 "Alice" 修改成 "Bob"。

而是：

让变量 name 重新指向了另一个字符串对象。

这叫：

重新赋值（Reassignment）

什么是可变类型？

可变（Mutable）

可以简单理解为：

对象创建后，可以修改其中的内容。

常见可变类型包括：

• list
• dict
• set

例如：

numbers = [1, 2, 3]

numbers.append(4)

print(numbers)

输出：

[1, 2, 3, 4]

这里列表本身被修改了。

type() 函数

如果不知道一个数据是什么类型，可以使用：

type()

例如：

greeting = "Hello"
age = 21

print(type(greeting))
print(type(age))

输出：

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

可以理解成：

greeting → str
age      → int

isinstance() 函数

isinstance() 用于：

判断一个对象是不是某种类型。

例如：

name = "Alice"
age = 18

print(isinstance(name, str))
print(isinstance(age, int))

输出：

True
True

如果类型不匹配：

print(isinstance(name, int))

输出：

False

可以简单记成：

type()
↓
“你是什么类型？”

isinstance()
↓
“你是不是这种类型？”

字符串（str）

字符串是 Python 中非常常用的数据类型。

例如：

name = "Alice"
city = "Singapore"
message = "Hello World"

字符串可以使用：

"双引号"

或者：

'单引号'

例如：

developer = "Jessica"
city = 'Singapore'

两种写法都可以。

建议在同一个项目中保持统一的编码风格。

字符串是不可变的

字符串属于：

不可变类型（Immutable Type）

例如：

name = "Alice"

不能直接修改其中某一个字符。

但是可以生成一个新的字符串：

name = "Bob"

这里实际上是让变量重新指向新的字符串。

访问字符串中的字符

字符串中的每个字符都有一个：

索引（Index）

索引从：

0

开始。

例如：

message = "Hello"

可以表示为：

字符： H  e  l  l  o
索引： 0  1  2  3  4

因此：

print(message[0])

输出：

H

负数索引

Python 还支持：

负数索引

从字符串最后一个字符开始计算。

例如：

字符：  H   e   l   l   o
正索引： 0   1   2   3   4
负索引：-5  -4  -3  -2  -1

所以：

message = "Hello"

print(message[-1])
print(message[-2])

输出：

o
l

可以记住：

-1 就是最后一个元素。

字符串转义（Escape）

如果字符串内部本身包含引号，就可能产生冲突。

例如：

msg = 'It's a sunny day'

Python 会不知道第二个 ' 是字符串的一部分，还是字符串结束符。

这时可以使用：

\

反斜杠进行转义。

例如：

msg = 'It\'s a sunny day'

也可以：

quote = "She said, \"Hello!\""

字符串拼接

字符串可以使用：

+

进行拼接。

例如：

developer = "Jessica"

message = "My name is " + developer + "."

print(message)

输出：

My name is Jessica.

所谓：

字符串拼接（String Concatenation）

就是：

把多个字符串连接成一个字符串。

使用 += 拼接字符串

+= 可以把：

拼接
+
重新赋值

合并到一起。

例如：

greeting = "My name is "
developer = "Jessica."

greeting += developer

print(greeting)

输出：

My name is Jessica.

可以理解成：

greeting = greeting + developer

f-string

Python 还有一种更加方便的字符串格式化方法：

f-string

它的全称是：

Formatted String Literal

即：

格式化字符串字面量。

使用方法是在字符串前加：

f

例如：

developer = "Jessica"

greeting = f"My name is {developer}."

print(greeting)

输出：

My name is Jessica.

其中：

{developer}

表示：

把变量 developer 的值放到这里。

相比大量使用 + 拼接，f-string 通常更加直观。

字符串切片

有时候我们只想取字符串的一部分。

这叫：

切片（Slicing）

基本语法：

string[start:stop:step]

三个部分分别表示：

例如：

message = "Python is fun!"

print(message[0:6])

输出：

Python

因为索引：

0 1 2 3 4 5
P y t h o n

切片：

[0:6]

包含 0~5，但不包含 6。

因此：

切片的结束位置通常是不包含的。

切片可以省略参数

例如：

message = "Python is fun!"

print(message[7:])

输出：

is fun!

表示：

从索引 7 开始，一直取到最后。

还可以：

print(message[:6])

表示：

从开头取到索引 6 之前。

切片的 step

例如：

message = "Python is fun!"

print(message[::2])

输出：

Pto sfn

这里：

::2

表示：

每隔一个字符取一个。

len() 函数

len() 用于获取：

对象的长度。

例如：

developer = "Jessica"

print(len(developer))

输出：

7

因为：

J e s s i c a

一共有：

7

个字符。

使用 in 判断内容是否存在

in 是一个非常常用的运算符。

它可以判断：

某个内容是否存在于另一个对象中。

例如：

message = "Hello World"

print("Hello" in message)
print("Python" in message)

输出：

True
False

也可以判断单个字符：

print("e" in message)

输出：

True

常用字符串方法

字符串提供了大量内置方法，可以帮助我们处理文字。

upper()：转换为大写

developer = "Jessica"

print(developer.upper())

输出：

JESSICA

lower()：转换为小写

developer = "Jessica"

print(developer.lower())

输出：

jessica

strip()：删除两端空白

例如：

greeting = "  hello world  "

result = greeting.strip()

print(result)

输出：

hello world

strip() 默认删除字符串：

开头和结尾的空白字符。

例如空格、换行等。

注意：

strip() 不会删除字符串中间的空格。

replace()：替换内容

greeting = "hello world"

result = greeting.replace("hello", "hi")

print(result)

输出：

hi world

它会返回一个：

新的字符串。

因为字符串本身是不可变的。

split()：拆分字符串

split() 可以把字符串：

按照指定分隔符拆成列表。

例如：

name = "Tom-Bob-Alice"

result = name.split("-")

print(result)

输出：

['Tom', 'Bob', 'Alice']

join()：连接字符串

join() 和 split() 可以理解成相反方向的操作。

例如：

names = ["Tom", "Bob", "Alice"]

result = "-".join(names)

print(result)

输出：

Tom-Bob-Alice

可以简单记：

split()
字符串 → 列表

join()
列表 → 字符串

startswith()：判断开头

name = "Naomi"

print(name.startswith("N"))

输出：

True

表示：

name 是否以 "N" 开头。

endswith()：判断结尾

name = "Naomi"

print(name.endswith("N"))

输出：

False

表示：

name 是否以 "N" 结尾。

find()：查找位置

find() 用来查找：

某个字符串第一次出现的位置。

例如：

name = "Naomi"

print(name.find("N"))

输出：

0

如果找不到：

city = "Los Angeles"

print(city.find("New"))

输出：

-1

所以：

找到 → 返回索引
找不到 → 返回 -1

count()：统计出现次数

city = "Los Angeles"

print(city.count("e"))

输出：

2

表示字符：

e

出现了两次。

capitalize()：首字母大写

dessert = "chocolate cake"

print(dessert.capitalize())

输出：

Chocolate cake

它会：

让第一个字符变成大写，其余字符变成小写。

isupper()：判断是否全为大写

dessert = "chocolate cake"

print(dessert.isupper())

输出：

False

islower()：判断是否全为小写

dessert = "chocolate cake"

print(dessert.islower())

输出：

True

title()：每个单词首字母大写

city = "los angeles"

print(city.title())

输出：

Los Angeles

maketrans() 和 translate()

这两个方法属于字符串中比较特殊的一组功能。

str.maketrans() 可以创建：

字符转换表。

然后通过：

translate()

使用这个转换表。

例如：

table = str.maketrans("abc", "123")

result = "abcabc".translate(table)

print(result)

输出：

123123

对应关系是：

a → 1
b → 2
c → 3

初学阶段只需要知道：

maketrans() 用来创建转换规则，translate() 用来应用转换规则。

数字的基本运算

Python 可以直接进行数学计算。

最常见的运算包括：

例如：

a = 56
b = 12

print(a + b)
print(a - b)
print(a * b)
print(a / b)

输出：

68
44
672
4.666666666666667

整数和浮点数一起计算

如果计算中出现浮点数，结果通常会成为浮点数。

例如：

integer = 56
number = 5.4

print(integer + number)

输出：

61.4

因此：

整数 + 浮点数
↓
通常得到浮点数

取模运算 %

% 叫：

取模运算符（Modulo Operator）

作用是：

获取除法运算后的余数。

例如：

print(56 % 12)

因为：

56 ÷ 12 = 4 …… 8

所以：

结果 = 8

程序输出：

8

取模经常用于：

• 判断奇偶数
• 判断是否整除
• 周期性计算

例如：

number = 10

print(number % 2)

输出：

0

说明 10 可以被 2 整除。

整除运算 //

// 表示：

地板除法（Floor Division）

简单理解：

做除法，然后向下取整。

例如：

print(56 // 12)

输出：

4

因为：

56 ÷ 12 = 4.666...

向下取整后：

4

幂运算 **

** 表示：

指数运算（Exponentiation）

例如：

print(4 ** 2)

相当于：

4 × 4

所以输出：

16

再例如：

print(2 ** 3)

输出：

8

常见数学运算速查表

float() 函数

float() 可以把能够表示成数字的数据转换为：

浮点数（float）

例如：

num = 4

print(float(num))

输出：

4.0

int() 函数

int() 可以将符合要求的数据转换成：

整数（int）

例如：

num = 4.0

print(int(num))

输出：

4

注意：

int() 转换浮点数时，不是四舍五入，而是直接去掉小数部分。

例如：

print(int(3.9))

输出：

3

round() 函数

round() 用于：

对数字进行四舍五入意义上的取整或保留指定小数位。

例如：

print(round(3.4))
print(round(7.7))

输出：

3
8

abs() 函数

abs() 表示：

Absolute Value（绝对值）

作用是：

获取一个数字的绝对值。

例如：

num = -13

print(abs(num))

输出：

13

pow() 函数

pow() 用来进行幂运算。

例如：

result = pow(2, 3)

print(result)

输出：

8

相当于：

2 ** 3

什么是增强赋值运算符？

英文叫：

Augmented Assignment Operators

可以理解为：

把“运算 + 赋值”合并成一步。

例如：

number = 10

number += 5

相当于：

number = number + 5

最终：

15

常见增强赋值运算符

例如：

count = 10

count += 5
print(count)  # 15

count -= 3
print(count)  # 12

count *= 2
print(count)  # 24

按位增强赋值

Python 还有一些用于：

位运算（Bitwise Operation）

的增强赋值运算符，例如：

&=
|=
^=
>>=
<<=

这些属于进阶内容。

初学阶段只需要知道它们也是：

运算 + 赋值

的缩写形式即可。

什么是函数（Function）？

函数可以理解成：

一段可以重复使用的代码。

例如：

def get_sum(num_1, num_2):
    return num_1 + num_2

调用：

result = get_sum(3, 4)

print(result)

输出：

7

函数通常可以：

接收数据
   ↓
执行任务
   ↓
返回结果

定义函数

Python 使用：

def

定义函数。

def 可以理解为：

define（定义）

的缩写。

基本语法：

def 函数名(参数):
    函数体

例如：

def greet():
    print("Hello")

这里：

调用函数

定义函数并不会自动执行。

例如：

def greet():
    print("Hello")

程序不会自动输出：

Hello

需要调用：

greet()

完整代码：

def greet():
    print("Hello")

greet()

输出：

Hello

函数参数

函数可以接收外部数据。

例如：

def get_sum(num_1, num_2):
    return num_1 + num_2

这里：

num_1
num_2

叫做：

参数（Parameter）

调用时：

get_sum(3, 4)

这里：

3
4

叫做：

实参（Argument）

可以简单记：

return 返回结果

return 用于：

把函数计算出来的结果交给调用者。

例如：

def get_sum(a, b):
    return a + b

result = get_sum(3, 4)

print(result)

输出：

7

执行过程：

get_sum(3, 4)
      ↓
计算 3 + 4
      ↓
return 7
      ↓
result = 7

print() 和 return 的区别

这是初学函数时非常容易混淆的地方。

例如：

def add(a, b):
    print(a + b)

result = add(1, 2)

print(result)

输出：

3
None

因为 print() 只是显示：

3

函数并没有返回 3。

函数默认返回 None

如果函数没有写 return：

def greet():
    print("hello")

调用：

result = greet()

函数执行完后：

result
↓
None

所以：

print(result)

输出：

None

可以简单理解成：

没有明确返回结果的函数，默认返回 None。

函数的默认参数

定义函数时，可以给参数设置一个：

默认值（Default Value）

例如：

def get_sum(num_1, num_2=2):
    return num_1 + num_2

调用：

result = get_sum(3)

print(result)

输出：

5

因为没有提供 num_2：

num_2 = 2

所以：

3 + 2 = 5

当然，也可以自己提供：

print(get_sum(3, 10))

输出：

13

参数数量错误

如果函数需要两个参数：

def calculate_sum(a, b):
    return a + b

但是只传入一个：

calculate_sum(1)

就会产生：

TypeError

因为：

缺少一个必须提供的参数。

如果一个函数需要几个必填参数，调用时就需要提供对应数量的实参。

常用内置函数

Python 自带了很多已经写好的函数。

这些叫：

内置函数（Built-in Functions）

常见函数包括：

input() 函数

input() 用于：

等待用户输入数据。

例如：

name = input("What is your name?")

print("Hello", name)

假设用户输入：

Kolade

输出：

Hello Kolade

注意：input() 返回的是字符串

这是非常重要的知识点。

例如：

age = input("请输入年龄：")

print(type(age))

用户输入：

18

输出仍然是：

<class 'str'>

因为：

input() 获取到的内容默认都是字符串。

如果需要把它变成整数：

age = int(input("请输入年龄："))

这样：

用户输入
↓
"18"
↓
int()
↓
18

int() 的常见转换

例如：

print(int(3.14))
print(int("42"))
print(int(True))
print(int(False))

输出：

3
42
1
0

其中：

True  → 1
False → 0

注意：

int("hello")

不能转换成整数，会产生错误。

同样：

int("3.14")

也不能直接转换。

什么是作用域（Scope）？

作用域（Scope）

可以理解成：

一个变量可以在哪些地方被访问。

简单来说：

变量不是在任何地方都一定能使用。

Python 中经常会遇到：

• 局部作用域
• 封闭作用域
• 全局作用域
• 内置作用域

这些规则共同参与 Python 的：

LEGB 查找规则

局部作用域（Local Scope）

如果变量是在函数内部创建的：

def my_func():
    num = 10
    print(num)

这里：

num

属于函数内部的局部变量。

通常只能在这个函数内部直接访问。

例如：

def my_func():
    num = 10
    print(num)

my_func()

输出：

10

封闭作用域（Enclosing Scope）

如果一个函数里面又定义了另一个函数：

def outer_func():
    msg = "Hello there!"

    def inner_func():
        print(msg)

    inner_func()

outer_func()

输出：

Hello there!

这里：

msg

属于外层函数。

内部函数：

inner_func()

可以访问外层函数中的变量。

这种外层嵌套函数产生的作用域，就是：

Enclosing Scope（封闭作用域）

全局作用域（Global Scope）

如果变量定义在所有函数之外：

tax = 0.70

def get_total(subtotal):
    total = subtotal + subtotal * tax
    return total

print(get_total(100))

输出：

170.0

这里：

tax = 0.70

位于函数外部，因此属于：

全局作用域（Global Scope）

函数内部可以读取这个变量。

内置作用域（Built-in Scope）

Python 自己还提供了一些内置名称。

例如：

print()
str()
int()
type()
len()
isinstance()

这些名称来自 Python 的：

Built-in Scope（内置作用域）

例如：

print(str(45))
print(type(3.14))
print(isinstance(3, str))

输出：

45
<class 'float'>
False

LEGB 查找规则

Python 查找变量时，可以简单理解为按照下面的顺序：

L → Local
局部作用域

E → Enclosing
封闭作用域

G → Global
全局作用域

B → Built-in
内置作用域

也就是：

局部
 ↓
封闭
 ↓
全局
 ↓
内置

如果 Python 在前面的作用域找到了变量，就会停止继续查找。

初学阶段记住：

Python 会按照 LEGB 顺序寻找变量。

即可。

比较运算符

程序经常需要比较两个数据。

例如：

3 大于 2 吗？
18 是否等于 18？
5 是否小于 10？

这时候就需要：

比较运算符（Comparison Operators）

常见比较运算符

== 和 = 不一样

这是初学者非常容易犯的错误。

=

表示：

赋值

例如：

age = 18

表示：

把 18 保存给 age

而：

==

表示：

判断两个值是否相等。

例如：

print(18 == 18)

输出：

True

可以简单记：

=   → 给变量赋值

==  → 比较是否相等

if 条件判断

程序有时候需要根据情况做不同的事情。

例如：

如果年龄 >= 18
    就显示“成年人”

这时候就需要：

if

if 可以理解为：

如果……那么……

例如：

age = 18

if age >= 18:
    print("You are an adult")

输出：

You are an adult

if 的基本结构

if 条件:
    要执行的代码

例如：

score = 90

if score >= 60:
    print("考试通过")

程序会先判断：

score >= 60

结果是：

True

于是执行缩进后的代码。

Python 非常重视缩进

Python 使用：

缩进（Indentation）

表示代码属于哪个代码块。

例如：

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

这里：

print("成年人")

前面的缩进非常重要。

不要写成：

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

这会产生错误。

因此要记住：

Python 中缩进不仅仅是排版，它还是代码结构的一部分。

elif：多个条件

如果有多个情况，可以使用：

elif

elif 可以理解为：

否则如果……

例如：

age = 16

if age >= 18:
    print("成年人")
elif age >= 13:
    print("青少年")

输出：

青少年

程序会按照顺序检查条件。

else：其他情况

如果前面的条件全部不成立，可以使用：

else

例如：

age = 12

if age >= 18:
    print("成年人")
elif age >= 13:
    print("青少年")
else:
    print("儿童")

输出：

儿童

可以理解为：

if
如果……

elif
否则如果……

else
否则……

if、elif、else 执行流程

可以理解成：

开始
 ↓
检查 if
 ↓
True？ ── 是 ──→ 执行 if
 ↓ 否
检查 elif
 ↓
True？ ── 是 ──→ 执行 elif
 ↓ 否
执行 else

在同一组：

if
elif
elif
else

结构中，通常只会执行其中一个分支。

嵌套 if

if 里面还可以继续使用 if。

这叫：

嵌套条件（Nested if）

例如：

is_citizen = True
age = 25

if is_citizen:
    if age >= 18:
        print("You are eligible to vote")
else:
    print("You are not eligible to vote")

执行逻辑可以理解为：

是不是公民？
    ↓
   是
    ↓
年龄是否 >= 18？
    ↓
   是
    ↓
允许投票

嵌套 if 可以使用，但嵌套太多会让代码越来越难读，因此实际开发中通常会尽量保持结构简单。

什么是真值和假值？

Python 中的很多数据，都可以被放进条件判断中。

例如：

if value:
    ...

Python 会判断：

value 是真值吗？

或者：

value 是假值吗？

这种机制叫：

Truthiness（真值判断）

常见假值（Falsy）

以下数据在条件判断中会被当作：

False

常见的包括：

None
False
0
0.0
""
[]
()
{}
set()

例如：

if "":
    print("执行")
else:
    print("不会执行")

因为：

空字符串
↓
假值
↓
False

常见真值（Truthy）

与假值相反，很多非空、非零的数据都会被当作真值。

例如：

print(bool(1))
print(bool("Hello"))
print(bool([1, 2, 3]))

输出：

True
True
True

简单记：

非零数字 → 真
非空字符串 → 真
非空列表 → 真

bool() 函数

如果想直接查看一个值是真还是假，可以使用：

bool()

例如：

print(bool(False))
print(bool(0))
print(bool(""))

输出：

False
False
False

再看：

print(bool(True))
print(bool(1))
print(bool("Hello"))

输出：

True
True
True

所以：

bool() 可以把一个值转换成对应的布尔值。

布尔运算符

Python 有三个非常重要的布尔运算符：

and
or
not

它们用于：

组合多个条件，形成更加复杂的判断。

and 运算符

and 可以理解成：

并且

例如：

age = 25
is_citizen = True

if is_citizen and age >= 18:
    print("You are eligible to vote")

这里必须同时满足：

是公民
并且
年龄 >= 18

两个条件都成立，整个条件才成立。

and 的短路

and 是一种：

短路运算符（Short-circuit Operator）

例如：

False and something

因为第一个值已经是假值，所以整个结果不可能是真值。

因此 Python 不需要继续判断后面的内容。

可以理解成：

第一个条件是假
↓
最终不可能为真
↓
停止判断

注意：and 不一定返回 True 或 False

这是一个非常容易被忽略的知识点。

例如：

print(True and 25)

输出：

25

因为 Python 的 and 并不一定直接返回布尔值。

它实际上会：

返回其中一个操作数。

例如：

print(False and 25)

输出：

False

可以先记住：

假值 and 任意值
→ 返回前面的假值

真值 and 任意值
→ 返回后面的值

or 运算符

or 可以理解成：

或者

例如：

age = 19
is_student = True

if age < 18 or is_student:
    print("可以享受学生优惠")

只要：

年龄 < 18

或者：

是学生

其中一个成立，就可以执行。

or 的短路

or 同样具有短路特性。

如果第一个值已经是真值：

True or something

最终结果已经确定为真值。

因此 Python 不需要继续计算后面的内容。

可以理解成：

第一个条件已经为真
↓
最终结果至少为真值
↓
停止继续判断

or 也不一定返回 True 或 False

例如：

print(19 or False)

输出：

19

因为 19 是真值。

Python 直接返回：

19

所以：

and 和 or 的结果可能是原来的操作数，而不一定是 True 或 False。

在 if 条件中，我们通常只关心它最终是真还是假。

not 运算符

not 可以理解成：

不是 / 取反

它会把一个值的布尔意义反过来。

例如：

print(not True)

输出：

False

再例如：

print(not False)

输出：

True

not 的常见例子

print(not "")
print(not "Hello")

print(not 0)
print(not 1)

输出：

True
False
True
False

原因：

""     → 假值 → not 后变 True
"Hello" → 真值 → not 后变 False

0      → 假值 → not 后变 True
1      → 真值 → not 后变 False

与 and 和 or 不同：

not 的结果一定是 True 或 False。

not 在条件判断中的应用

例如：

is_admin = False

if not is_admin:
    print("Access denied")
else:
    print("Welcome, Administrator!")

输出：

Access denied

因为：

is_admin = False

所以：

not is_admin
↓
not False
↓
True

于是执行 if 中的代码。

and、or、not 速查表

最简单的记忆方法：

and → 并且
or  → 或者
not → 不是

Python 基础知识总览

到这里，我们已经接触了 Python 最重要的一批基础知识。

可以把它们整理成：

Python 基础
│
├── 变量
│   └── 保存数据
│
├── 数据类型
│   ├── int
│   ├── float
│   ├── str
│   ├── bool
│   ├── list
│   ├── tuple
│   ├── set
│   ├── dict
│   └── None
│
├── 字符串
│   ├── 索引
│   ├── 切片
│   ├── 拼接
│   └── 常用方法
│
├── 数字运算
│   ├── +
│   ├── -
│   ├── *
│   ├── /
│   ├── %
│   ├── //
│   └── **
│
├── 函数
│   ├── def
│   ├── 参数
│   ├── 实参
│   └── return
│
├── 作用域
│   ├── Local
│   ├── Enclosing
│   ├── Global
│   └── Built-in
│
├── 条件判断
│   ├── if
│   ├── elif
│   └── else
│
└── 布尔逻辑
    ├── and
    ├── or
    └── not

Python 基础速查表

学习小结

这一篇主要掌握以下内容：

• 变量：用一个名字保存数据。
• 数据类型：不同的数据有不同的类型，例如 int、float、str、bool。
• 字符串：可以进行索引、切片、拼接以及各种文字处理。
• 列表、元组、集合、字典：都是用于保存多个数据的常见容器。
• 可变与不可变：有些对象创建后不能直接修改，有些对象可以修改。
• 函数：把一段代码封装起来，方便重复使用。
• 作用域：决定变量可以在哪些地方被访问。
• 比较运算符：用于比较数据，例如 ==、>、<。
• 条件判断：使用 if、elif、else 让程序根据不同情况执行不同代码。
• 布尔值：True 和 False 是 Python 中最基础的逻辑值。
• and、or、not：用于组合和反转条件。
• 短路运算：and 和 or 在结果已经确定时，会停止继续计算。

总结

Python 基础可以先抓住几个核心概念：

变量
↓
保存数据

数据类型
↓
说明数据是什么

运算符
↓
处理数据

函数
↓
封装并重复使用代码

条件判断
↓
让程序做决定

作用域
↓
决定变量在哪里可以使用

对于刚开始学习 Python 的人来说，不需要一开始就把所有语法全部背下来。

更重要的是理解：

数据是什么 → 数据保存在哪里 → 如何处理数据 → 如何根据结果做决定。

当这些基础概念掌握之后，再继续学习：

循环
↓
列表与字典进阶
↓
函数进阶
↓
文件操作
↓
异常处理
↓
模块与包
↓
面向对象

就会更加容易。