曦杨

外观

Python基本语法

约 3804 字大约 13 分钟

2026-08-12

语言基本特征

  • 解释型
  • 强类型
  • 动态类型
  • 面向对象

注释

# 这是单行注释

"""
这是多行注释
可以写多行
"""

'''
这也是多行注释
可以写多行
'''

数据类型

类别类型名字面量说明
数字类型int1, 2, -3, 0支持无限大小
数字类型float1.5, -0.3, 2e1064位双精度
数字类型complex1+2j, 3-4jj表示$\sqrt{-1}$
数字类型
布尔类型		boolTrue, FalseTrue是1的别名
False是0的别名
字符串str"hello", 'world'
空值NoneTypeNone
容器类型多种类型后续介绍list/tuple/...

原子类型/基本内置类型/标量类型：int、float、complex、bool、str、NoneType

容器类型：list、tuple、...

# 整数（多种进制）
print(42)       # 十进制
print(0b1010)   # 二进制 = 10
print(0o52)     # 八进制 = 42
print(0x2A)     # 十六进制 = 42

# 浮点数（多种写法）
print(3.14)     # 小数形式
print(-0.5)     # 负数
print(2.5e10)   # 科学计数法 = 25000000000.0
print(1.2e-3)   # 负指数 = 0.0012

# 布尔值
print(True)     # 真
print(False)    # 假

# 字符串（单双引号等价）
print("hello")  # 双引号
print('world')  # 单引号
print('''Hello
world''')  # 多行字符串
print("""Hello
world""")  # 多行字符串

# 空值
print(None)     # 空值

type函数

# 整数
print(type(42))       # <class 'int'>
print(type(0b1010))   # <class 'int'>
print(type(0o52))     # <class 'int'>
print(type(0x2A))     # <class 'int'>

# 浮点数
print(type(3.14))     # <class 'float'>
print(type(-0.5))     # <class 'float'>
print(type(2.5e10))   # <class 'float'>
print(type(1.2e-3))   # <class 'float'>

# 布尔值
print(type(True))     # <class 'bool'>
print(type(False))    # <class 'bool'>

# 字符串
print(type("Hello"))  # <class 'str'>
print(type('World'))  # <class 'str'>

# 空值
print(type(None))     # <class 'NoneType'>

注意：type函数返回的不是字符串，而是类型对象

print(type(42) == int) # True

变量

变量定义

Python是动态类型语言，变量无需声明类型，直接赋值即可创建。

# 变量赋值
name = "Alice"      # 字符串
age = 25            # 整数
pi = 3.14159        # 浮点数
is_valid = True     # 布尔值

变量命名规则

规则说明示例
字母/下划线开头变量名必须以字母或下划线开头name, _value
区分大小写Name 和 name 是不同的变量Name = 1, name = 2
不能是关键字不能使用Python保留字if, for, class 等
只能包含字母/数字/下划线不能包含空格或特殊字符user_name, value2

关键字（不能作为变量名）：False, None, True, and, as, assert, async, await, break, class, continue, def, del, elif, else, except, finally, for, from, global, if, import, in, is, lambda, nonlocal, not, or, pass, raise, return, try, while, with, yield

# 有效命名
user_name = "张三"
_age = 25
MAX_SIZE = 100
value2 = 3.14

# 无效命名（会报错）
# 2value = 10      # 数字开头
# user-name = "a"  # 包含连字符
# class = 5        # 关键字

命名规范

类型规范示例
变量名小写字母，下划线分隔（snake_case）user_name, total_count
常量名全大写字母，下划线分隔MAX_SIZE, PI
类名首字母大写的驼峰命名（PascalCase）UserInfo, DataModel
私有变量以下划线开头_internal, __private

多重赋值

# 同时赋值多个变量
a, b, c = 1, 2, 3

# 交换变量值
x, y = 10, 20
x, y = y, x  # x=20, y=10

# 相同值赋给多个变量
a = b = c = 0  # a=0, b=0, c=0

变量类型转换

# 字符串转整数
age_str = "25"
age_int = int(age_str)      # 25

# 整数转字符串
num = 100
num_str = str(num)          # "100"

# 整数转浮点数
x = 5
x_float = float(x)          # 5.0

# 浮点数转整数（截断小数）
y = 3.9
y_int = int(y)              # 3（不是四舍五入）

# 转布尔值
print(bool(0))      # False
print(bool(1))      # True
print(bool(""))     # False
print(bool("hi"))   # True

字符串格式化（f-string）

Python 3.6+ 引入了 f-string（格式化字符串字面量），是最简洁、最常用的字符串格式化方式。

在字符串前加 f 或 F，在花括号 {} 中直接嵌入变量或表达式：

name = "Alice"
age = 25
print(f"姓名: {name}, 年龄: {age}")  # 姓名: Alice, 年龄: 25

# 直接嵌入表达式
a, b = 3, 5
print(f"{a} + {b} = {a + b}")       # 3 + 5 = 8

运算符

算术运算符

运算符名称intfloatstrboolNoneType
+加法数值相加数值相加字符串拼接True=1, False=0不支持
-减法数值相减数值相减不支持True=1, False=0不支持
*乘法数值相乘数值相乘字符串重复True=1, False=0不支持
/除法返回float返回float不支持True=1, False=0不支持
//整除整数除法整数除法不支持True=1, False=0不支持
%取余取余数取余数不支持True=1, False=0不支持
**幂运算幂运算幂运算不支持True=1, False=0不支持
# int
print(5 + 3)        # 8
print(5 - 3)        # 2
print(5 * 3)        # 15
print(5 / 3)        # 1.666...
print(5 // 3)       # 1
print(5 % 3)        # 2
print(5 ** 3)       # 125

# float
print(5.0 + 3.0)    # 8.0
print(5.0 - 3.0)    # 2.0
print(5.0 * 3.0)    # 15.0
print(5.0 / 3.0)    # 1.666...
print(5.0 // 3.0)   # 1.0
print(5.0 % 3.0)    # 2.0
print(5.0 ** 3.0)   # 125.0

# str
print("Hello" + "World")  # "HelloWorld"
print("Hi" * 3)           # "HiHiHi"

# bool (True=1, False=0)
print(True + True)   # 2
print(True * 5)      # 5
print(False * 10)    # 0

# NoneType - 所有算术运算都会报错
# print(None + 1)   # TypeError

比较运算符

运算符名称intfloatstrboolNoneType
==等于数值比较数值比较内容比较True==1, False==0None==None
!=不等于数值比较数值比较内容比较True!=0None!=非None
<小于数值比较数值比较字典序比较True=1, False=0不支持
>大于数值比较数值比较字典序比较True=1, False=0不支持
<=小于等于数值比较数值比较字典序比较True=1, False=0不支持
>=大于等于数值比较数值比较字典序比较True=1, False=0不支持
# int
print(5 == 5)       # True
print(5 != 3)       # True
print(5 > 3)        # True

# float
print(5.0 == 5.0)   # True
print(5.0 != 3.0)   # True
print(5.0 > 3.0)    # True

# str (按字典序/ASCII码比较)
print("abc" == "abc")     # True
print("abc" != "def")     # True
print("abc" < "def")      # True
print("A" < "a")          # True (A=65, a=97)

# bool
print(True == 1)          # True
print(False == 0)         # True
print(True > False)       # True

# NoneType
print(None == None)       # True
print(None != 0)          # True
print(None != False)      # True
# print(None > 0)         # TypeError

链式比较

Python 支持链式比较，可以像数学公式一样连续写比较运算符：

x = 5

# 传统写法（其他语言）
print(x > 1 and x < 10)   # True

# Python 链式比较（更简洁）
print(1 < x < 10)         # True
print(1 < x <= 5)         # True
print(5 <= x < 10)        # True
print(1 < x < 3)          # False

# 甚至可以更复杂
print(1 < x < 10 < 100)   # True

等价规则： a < b < c 等价于 a < b and b < c，但只计算一次 b。

赋值运算符

运算符示例等价于适用类型
=a = 5-所有类型
+=a += 3a = a + 3int, float, str
-=a -= 3a = a - 3int, float
*=a *= 3a = a * 3int, float, str
/=a /= 3a = a / 3int, float
//=a //= 3a = a // 3int, float
%=a %= 3a = a % 3int, float
**=a **= 3a = a ** 3int, float
# int
a = 10
a += 5    # a = 15
a -= 3    # a = 12
a *= 2    # a = 24
a /= 4    # a = 6.0 (注意：/= 结果变为float)

# str
s = "Hello"
s += " World"  # s = "Hello World"
s *= 2         # s = "Hello WorldHello World"

海象运算符（:=）

Python 3.8 引入的赋值表达式，可以在表达式中同时进行赋值和求值。

# 传统写法：先赋值，再判断
line = input("输入: ")
while line != "quit":
    print(f"你输入了: {line}")
    line = input("输入: ")

# 使用海象运算符：赋值和判断合二为一
while (line := input("输入: ")) != "quit":
    print(f"你输入了: {line}")

注意： 海象运算符是 Python 3.8 的新特性，老版本不支持。

逻辑运算符

运算符说明返回值规则
and逻辑与第一个为False则返回第一个，否则返回第二个
or逻辑或第一个为True则返回第一个，否则返回第二个
not逻辑非返回True或False

各类型真假值：

  • int: 0为False，其他为True
  • float: 0.0为False，其他为True
  • str: ""为False，其他为True
  • bool: False为False，True为True
  • NoneType: None为False
# int
print(0 and 5)        # 0 (0为False，返回0)
print(3 and 5)        # 5 (3为True，返回5)
print(0 or 5)         # 5 (0为False，返回5)
print(3 or 5)         # 3 (3为True，返回3)
print(not 0)          # True
print(not 5)          # False

# float
print(0.0 and 5.0)    # 0.0
print(3.0 and 5.0)    # 5.0
print(not 0.0)        # True

# str
print("" and "hello") # "" (空字符串为False)
print("hi" and "hello") # "hello"
print(not "")         # True
print(not "hello")    # False

# bool
print(True and False)  # False
print(True or False)   # True
print(not True)        # False

# NoneType
print(None and True)   # None
print(None or True)    # True
print(not None)        # True

三元运算符（条件表达式）

Python 的三元运算符（条件表达式）是一种简洁的 if-else 写法，用于在一行中根据条件选择不同的值。

语法：

结果 = 真值 if 条件 else 假值
score = 85

# 传统写法
if score >= 60:
    result = "及格"
else:
    result = "不及格"

# 三元运算符（更简洁）
result = "及格" if score >= 60 else "不及格"
print(result)  # 及格

# 嵌套三元运算符（不推荐过度嵌套）
age = 25
category = "青年" if age < 40 else ("中年" if age < 60 else "老年")

注意： 三元运算符适合简单的条件判断，复杂的逻辑应使用传统的 if-else 结构以保持代码可读性。

输入输出

print输出

# 输出字符串
print("Hello, World!")

# 输出多个值，用空格分隔
print("年龄:", 25)

# 自定义分隔符
print("a", "b", "c", sep="-")  # a-b-c

# 自定义结束符（默认换行）
print("Hello", end=" ")
print("World")  # Hello World

input输入

# 接收用户输入，返回字符串类型
name = input("请输入你的名字: ")
print("你好,", name)

# input返回的是字符串
age_str = input("请输入年龄: ")
age = int(age_str)  # 需要转换为整数
print("明年你", age + 1, "岁")

流程控制

条件判断

语法说明
if 条件:条件为True时执行
elif 条件:前一个条件为False且当前条件为True时执行
else:前面所有条件都为False时执行
# 基本if-else
age = 18
if age >= 18:
    print("成年人")
else:
    print("未成年人")

# if-elif-else
score = 85
if score >= 90:
    grade = "A"
elif score >= 80:
    grade = "B"
elif score >= 60:
    grade = "C"
else:
    grade = "D"
print(f"成绩等级: {grade}")

# 单行if-else（三元表达式）
result = "通过" if score >= 60 else "不及格"

注意： Python使用缩进（通常为4个空格）表示代码块，不使用花括号。

pass占位符

pass是Python中的占位符语句，不执行任何操作，用于语法上需要语句但逻辑上暂时不需要的情况。

# 空循环体
i = 0
while i < 5:
    pass  # 暂时不执行任何操作
    i += 1

# 空代码块（占位）
if True:
    pass  # 待实现

循环

while循环

# 基本while循环
count = 0
while count < 5:
    print(count)
    count += 1

# 带条件的while循环
user_input = ""
while user_input != "quit":
    user_input = input("输入'quit'退出: ")
    print(f"你输入了: {user_input}")

循环控制语句

语句作用
break立即终止整个循环
continue跳过当前迭代，进入下一次循环
# break - 找到第一个大于5的数就停止
num = 1
while num <= 10:
    if num > 5:
        print(f"找到大于5的数: {num}")
        break
    num += 1

# continue - 跳过奇数，只打印偶数
num = 0
while num < 10:
    if num % 2 != 0:
        num += 1
        continue
    print(num)  # 0, 2, 4, 6, 8
    num += 1

循环else子句

循环可以带有一个else子句，当循环正常结束（没有被break中断）时执行。

# while循环的else
count = 0
while count < 3:
    print(count)
    count += 1
else:
    print("while循环正常完成")

# 典型用法：查找元素
num = 1
while num <= 9:
    if num == 4:
        print("找到: 4")
        break
    num += 2  # 模拟遍历奇数1, 3, 5, 7, 9
else:
    print("未找到: 4")  # 会执行，因为4不在奇数序列中

重要区别：

  • 循环被break中断 → 不执行else
  • 循环正常结束（包括continue）→ 执行else

作业

作业答案在./answers中

作业一：代码输出结果预测

阅读以下代码，预测每行 print 的输出结果，并在注释中写出你的答案。

# 变量定义
a = 10
b = 3.5
c = "Python"
d = True
e = None

# 1. 数据类型与 type 函数
print(type(a))
print(type(b))
print(type(c))
print(type(d))
print(type(e))
print(type(a) == int)

# 2. 变量类型转换
print(int(b))
print(float(a))
print(str(a) + c)
print(bool(0))
print(bool(""))
print(bool("hello"))

# 3. 算术运算符
print(a + 5)
print(a / 4)
print(a // 4)
print(a % 4)
print(a ** 2)
print(c * 2)

# 4. 字符串格式化（f-string）
name = "Alice"
age = 25
print(f"姓名: {name}, 年龄: {age}")
print(f"明年{age + 1}岁")
print(f"{a} + {5} = {a + 5}")

# 5. 比较运算符与链式比较
print(a > 5)
print(a == 10)
print(5 < a < 20)
print(c == "python")
print("A" < "a")

# 6. 逻辑运算符
print(True and False)
print(True or False)
print(not d)
print(0 and 5)
print(3 or 5)
print("" and "hello")
print("hi" or "hello")
print(not None)

# 7. 三元运算符
score = 85
result = "及格" if score >= 60 else "不及格"
print(result)
level = "A" if score >= 90 else ("B" if score >= 80 else "C")
print(level)

# 8. 赋值运算符
x = 10
x += 5
print(x)
x -= 3
print(x)
x *= 2
print(x)
x /= 4
print(x)

s = "Hi"
s += " Python"
print(s)
s *= 2
print(s)

作业二：循环与判断代码输出预测

阅读以下代码，预测每行 print 的输出结果，并在注释中写出你的答案。

# 1. while 循环 + if-else
n = 1
result = 0
while n <= 5:
    if n % 2 == 0:
        result += n
    else:
        result -= n
    n += 1
print(result)

# 2. continue 和 break
num = 1
while num <= 10:
    if num == 3:
        num += 1
        continue
    if num == 7:
        break
    print(num)
    num += 1

# 3. 循环 else 子句
i = 0
while i < 3:
    print(i)
    i += 1
else:
    print("end")

# 4. 嵌套条件
x = 15
if x < 10:
    print("A")
elif x < 20:
    if x % 2 == 0:
        print("B")
    else:
        print("C")
else:
    print("D")

# 5. 综合练习
a = 1
b = 0
while a <= 5:
    if a == 3:
        b += 10
    elif a % 2 == 0:
        b += a * 2
    else:
        b += a
    a += 1
print(b)

作业三：BMI 计算器

编写一个 BMI 计算器程序，要求如下：

  1. 用户输入：通过 input() 函数获取用户的身高（单位：米）和体重（单位：千克）。

  2. 计算 BMI：使用公式 BMI = 体重(kg) / 身高(m)² 计算 BMI 值。

  3. 判断分类：根据 BMI 值判断身体状况（参考中国成人标准）：

    • BMI < 18.5：偏瘦
    • 18.5 ≤ BMI < 24：正常
    • 24 ≤ BMI < 28：超重
    • BMI ≥ 28：肥胖

  4. 输出结果：使用 f-string 格式化输出用户的 BMI 值和分类结果。

  5. 健康建议：根据分类结果给出相应的健康建议，例如：

    • 偏瘦：建议适当增加营养摄入，进行适量运动
    • 正常：保持良好的生活习惯
    • 超重/肥胖：建议控制饮食，增加运动量

示例输出：

请输入您的身高（米）：1.75
请输入您的体重（千克）：70
您的 BMI 值为：22.86
身体状况：正常
建议：保持良好的生活习惯，继续保持！

作业四：素数筛选器

素数（质数） 是指在大于 1 的自然数中，除了 1 和它本身以外不再有其他因数的数。例如：2、3、5、7、11 都是素数，而 4、6、8、9 则不是。

编写一个程序，要求如下：

  1. 用户输入：通过 input() 函数获取起始数字和结束数字。

  2. 输入合法性检查：

    • 输入必须是正整数（大于 0 的整数）
    • 结束数字必须大于起始数字
    • 如果输入不合法，给出相应提示并要求重新输入

  3. 素数判断：使用循环判断该范围内每个数字是否为素数。

  4. 输出结果：打印该范围内的所有素数，并统计素数的个数。

示例输出：

请输入起始数字：10
请输入结束数字：50
10 到 50 之间的素数有：
11 13 17 19 23 29 31 37 41 43 47
共计 11 个素数