Python 入门手札：从 0 到会--第四天Python的基础--语句&&函数
目录
一、语句
语句是计算机执行程序的最小单位。
1. 赋值语句
赋值语句将一个值赋给变量：
a = 5 # 将值 5 赋给变量 a
b = a + 2 # 计算 a + 2 并将结果赋给 b2. 条件语句
条件语句用于根据不同的条件来执行不同的代码块。
2.1 if-elif-else
常见的条件语句有 if、elif 和 else
语法
if 条件表达式1: 语句块1 elif 条件表达式2: 语句块2 ... elif 条件表达式n: 语句块n else: 语句块(其他)
案例：
x = 10
if x > 0:
print("x 是正数")
elif x == 0:
print("x 是零")
else:
print("x 是负数")2.2 match-case
在Python3.10版本后更新了match-case语句：
当存在多个判断环境时，if-elif-else语句会比较臃肿
在判断条件较为简单的前提下，可使用match case来进行多条件判断
当x与对应的case匹配后，立刻结束判断，无论后续的case是否匹配
x = 20
match x:
case 10:
print("x is 10")
case 20:
print("x is 20")
case _:
print("x is not 10 ether 20")
# case条件判断并不要求为单一条件，可以进行多条件判断
x = 20
match x:
case 10 | 20 | 30:
print("x为10、20、30中的一个")
case _:
print("x不为10、20、30中的任何一个")
# match case支持在判断条件中套用if判断
x=20
match x:
case x if x>10:
print("x大于10")
case x if x<30:
print("x大于10小于30")3. 循环语句
循环语句用于重复执行一段代码，直到满足某个条件。常见的循环语句有 for 循环和 while 循环。
3.1 for循环
遍历可迭代对象（如列表、元组、字典等）
遍历是指经历且只经历一遍
可迭代对象是指能够依次获取数据元素的对象
for i in range(5):
print(i) # 输出 0, 1, 2, 3, 43.2 while循环
当条件为 $True$ 时重复执行
-
语法
while 真值表达式: 语句块1 (*此部分可能会重复执行) else: 语句块2
-
参考代码
count = 0 while count < 5: print(count) count += 1 # 输出 0, 1, 2, 3, 4 -
while循环是可以嵌套的
3.3 range
-
作用
用来生成一个能够得到一系列整数的可迭代对象（也叫整数序列生成器）
-
调用格式
range(stop) # stop 停止整数 range(start, stop) # start 开始整数 range(start, stop, step) # step 步长range 函数调用会生成从 start 开始，到 stop 结束(不包含stop) 的一系列整数，整数的间隔 step
start 默认值为0, step 默认值为1
-
示意
range(4) # 生成 0 1 2 3 range(3, 6) # 生成 3 4 5 range(1, 10, 2) # 生成 1 3 5 7 9 range(5, 0, -2) # 生成 5 3 1
3.4 练习合集
-
练习1
写一个程序 打印1~20 的整数, 打印在 1 行内 每个数字之间用一个空格分隔开 1 2 3 4 5 ... 19 20 以上输出打印 10 行
参考代码：
i = 0 while i < 10: # print('1 2 3 4 5 6 7.... 20') x = 1 while x <= 20: print(x, end=' ') x += 1 # 等同于 x = x + 1 print() # 打印一个换行 '\n' i += 1 -
练习2
写程序，输入一个整数n , 代表结束的整数， 计算 1 + 2 + 3 + 4 + ..... + n 的和 请输入: 100 5050 # 提示： he = 0 # 用一个变量来记录这个和
参考代码：
n = int(input('请输入一个整数： ')) he = 0 i = 1 while i <= n: he += i i += 1 print(he) -
练习3
打印 1~ 20 的整数, 每行打印 5 个， 打印 四行, 如: 1 2 3 4 5 6 7 8 9 10 ... 16 17 18 19 20 # 提示: print() 换行
参考代码：
x = 1 while x <= 20: print('%2d' % x, end=' ') if x % 5 == 0: print() # 换行 x += 1 print() -
练习4
# 某人有100,000元,每经过-次路口,需要交费,规则如下: # 1)当现金> 50000时每次交5% # 2)当现金< = 50000时,每次交1000, # 编程计算该人可以经过多少次路口
参考代码：
money = 100000 n = 0 while money >= 1000: n += 1 money = 0.95*money if money > 50000 else money - 1000 print('共可以过桥' + str(n) + '次') -
练习5
写程序，计算 1 + 3 + 5 + 7 + ..... + 97 + 99 的和 分别用 for 循环和 while 实现。
参考代码：
# 用 while 语句实现 total = 0 x = 1 while x < 100: # print(x, end=' ') total += x x += 2 print('1 + 3 + 5 + 7 + .... + 99=', total) # 用 for 语句实现 total = 0 for x in range(1, 100, 2): # print(x, end=' ') total += x print('1 + 3 + 5 + 7 + .... + 99=', total)
4. 死循环
death loop
死循环是指循环条件一直成立的循环
死循环通常使用 break 语句来终止循环
写法
while True:
语句块死循环通常用于循环次数无法确定的循环
5. 循环控制语句
跳转语句用于控制程序的执行流程。
5.1 break
跳出整个循环。
for i in range(5):
if i == 3:
break # 退出循环
print(i)
# 输出：0, 1, 25.2 continue
跳过当前循环，继续下一次循环。
for i in range(5):
if i == 3:
continue # 跳过打印 3
print(i)
# 输出：0, 1, 2, 45.3 pass
占位符，什么也不做，通常用于占据语法上必须有代码的地方。
def empty_function():
pass # 这里不做任何事情5.4 练习
-
练习1
假设一个用户信息如下: 用户名是:root 密码是: 123456 写一个身份验证的程序，让用户输入用户名和密码登录, 用户名和密码全部匹配，提示登录成功。 否则继续，最多尝试3次。3次不匹配以后提示登录失败.
参考代码：
# 正确的用户名和密码 correct_username = "root" correct_password = "123456" # 最多尝试3次 max_attempts = 3 attempts = 0 while attempts < max_attempts: # 获取用户输入 username = input("请输入用户名: ") password = input("请输入密码: ") # 验证用户名和密码 if username == correct_username and password == correct_password: print("登录成功！") break else: attempts += 1 remaining_attempts = max_attempts - attempts if remaining_attempts > 0: print(f"用户名或密码错误，还剩 {remaining_attempts} 次尝试。") else: print("登录失败，已超过最大尝试次数。")
6.函数定义语句
用于定义一个函数，包含 def 关键字：
def greet(name):
print(f"Hello, {name}!")
greet("Alice") # 调用函数7. 异常处理语句（重点）
7.1 try...except...finally
用途：
用于捕捉运行时错误，从而避免程序崩溃，并可以提供自定义的错误处理方式。
语法结构：
try:
# 可能会出错的代码
except 错误类型1:
# 对应错误的处理代码
except 错误类型2 as e:
# 获取错误对象，进行处理
else:
# 没有发生异常时执行的代码
finally:
# 无论是否发生异常，都会执行的代码示例 1：简单异常捕获
try:
result = 10 / 0
except ZeroDivisionError:
print("除以零错误！")
finally:
print("无论如何都会执行。")输出：
复制编辑除以零错误！
无论如何都会执行。示例 2：捕获多个异常
try:
x = int("abc")
except ValueError:
print("转换错误：不是有效的整数")
except Exception as e:
print("其他错误：", e)7.2 断言语句：assert
用途：
调试时使用，断言某个条件为 True，如果为 False，程序抛出 AssertionError。
语法结构：
assert 条件表达式, "出错提示"示例：
x = 10
assert x > 0, "x 应该为正数"
assert x < 5, "x 太大了"输出：
makefile
AssertionError: x 太大了⚠️
assert语句可以在解释器加上-O参数时被忽略（优化模式）。
7.3 主动抛出异常：raise
用途：
当程序遇到非法状态或想自定义错误时，使用 raise 抛出异常。
语法结构：
raise 异常类型("异常信息")示例：
def set_age(age):
if age < 0:
raise ValueError("年龄不能为负数！")
print(f"年龄为 {age}")
set_age(-5)输出：
makefile
ValueError: 年龄不能为负数！7.4 总结对比表格
| 类型 | 关键字 | 用途 | 是否中断程序 | 是否可捕获 |
|---|---|---|---|---|
| 异常处理 | try except |
捕获并处理运行时错误 | 否 | 是 |
| 断言 | assert |
检查条件是否为 True | 是 | 是 |
| 主动抛异常 | raise |
自定义异常信息主动抛出 | 是 | 是 |
7.5 错误类型表格
错误类型
| 错误类型 | 说明 |
|---|---|
| ZeroDivisionError | 除(或取模)零 (所有数据类型) |
| ValueError | 传入无效的参数 |
| AssertionError | 断言语句失败 |
| StopIteration | 迭代器没有更多的值 |
| IndexError | 序列中没有此索引(index) |
| IndentationError | 缩进错误 |
| OSError | 输入/输出操作失败 |
| ImportError | 导入模块/对象失败 |
| NameError | 未声明/初始化对象 (没有属性) |
| AttributeError | 对象没有这个属性 |
详见：help(builtins)
二、函数
1.函数的定义
什么是函数（function）？
函数是组织好的，可重复使用的，用来实现某一特定功能的代码块。
在 Python 中，用 def 关键字来定义函数。
基本语法：
def 函数名(参数1, 参数2, ...):
"""可选的文档字符串"""
函数体（代码块）
return 返回值（可选）示例：
def greet(name):
print(f"你好，{name}！")这是一个接受一个参数 name 的函数，调用时传入一个名字，它会输出问候语
2.形参和实参
-
形参（形式参数）：
定义函数时使用的变量名。
它是“占位符”，真正调用函数时才会被赋值。
示例中 name 是形参：
def greet(name): # name 是形参
print(f"你好，{name}")-
实参（实际参数）：
-
调用函数时传入的具体值。
调用示例中 "小明" 是实参：
greet("小明") # 实参为 "小明"举例说明：
def add(a, b): # a 和 b 是形参
return a + b
result = add(3, 5) # 3 和 5 是实参
print(result) # 输出：82.1更多参数类型
2.1.1. 默认参数
def greet(name="朋友"):
print(f"你好，{name}！")
greet() # 没有传参，使用默认值：朋友
greet("小李") # 输出：你好，小李！2.1.2 关键字参数（传参时指定参数名）
def describe_pet(animal, name):
print(f"这是一只{animal}，名字叫{name}")
describe_pet(animal="猫", name="咪咪")2.1.3. 可变参数（不定数量）
🟡 *args：接收多个位置实参
def total(*numbers):
print(numbers)
return sum(numbers)
print(total(1, 2, 3, 4)) # 输出 10🟡 kwargs：接收多个关键字实参**
def show_info(**person):
print(person)
show_info(name="小张", age=20)3.函数的调用
函数调用（Function Call）
函数定义之后，需要使用“函数名 + 括号”来调用它。可以传入实参，也可以省略（如果函数无参数）。
调用方式：
def say_hello():
print("Hello!")
say_hello() # 调用函数4.函数的返回值
函数返回值（return）
def square(x):
return x * x
result = square(4)
print(result) # 输出：165.函数的封装
什么是“封装函数”？
封装函数（Encapsulate a function），指的是把某一段功能明确的代码，用
def封装到一个函数里，使其可以重复调用、易于维护，并且提高代码的可读性和可重用性。
你可以简单理解为：
把一段重复的、有意义的操作，打包成一个函数。
举个生活化例子：
假设你写一个程序，每次都要输出一段欢迎语：
print("欢迎使用我的程序！")
print("请按照提示输入数据。")你可能在很多地方重复使用这些语句。那就可以“封装”成一个函数：
def show_welcome():
print("欢迎使用我的程序！")
print("请按照提示输入数据。")以后只要这样写即可：
show_welcome()封装函数的好处：
| 优点 | 说明 |
|---|---|
| 避免重复代码 | 把重复使用的逻辑封装起来 |
| 让代码更整洁 | 每个函数只做一件事，易读 |
| 提高可维护性 | 改动功能时，只改函数内部即可 |
| 可复用性强 | 不同地方可多次调用 |
示例：封装一个计算 BMI 的函数
def calculate_bmi(weight, height):
"""根据体重和身高计算 BMI 指数"""
bmi = weight / (height ** 2)
return bmi调用方式：
my_bmi = calculate_bmi(60, 1.7)
print("你的 BMI 是：", my_bmi)总结一句话：
封装函数，就是把某段逻辑用
def包裹起来，做成一个“工具”，可以随时拿来用。
5.1封装函数一定要用return吗？
怎么才算“封装好了一个函数”？
封装好的函数，不一定非要有 return，但通常要满足以下这些“封装良好”的特征：
1. 明确一个单一功能
函数应该只做一件事，比如：
计算面积
打印欢迎语
读取文件
同时下载文件+解析+保存 ❌（功能太多）
2. 有良好的命名和参数设计
函数名清晰，参数设计合理：
def greet_user(name): # 清晰：打招呼 + 用户名
print(f"你好，{name}")3. 便于重复使用
只要别人知道函数的名字和参数，就能用它，而不用关心里面的实现细节。
4. 封装好的函数不一定要有 return
看下面两个例子
不需要返回值的函数：
def say_hello():
print("Hello!") # 只是打印，不需要结果返回调用后效果：
say_hello() # 输出：Hello! 这是封装得很好的函数，即使没有 return
有返回值的函数：
def square(x):
return x * x调用时可以获取结果：
result = square(5)
print(result) # 输出：25 如果你需要函数“告诉你一个结果”，就应该用 return
所以什么时候需要
return？
| 情况 | 是否需要 return |
|---|---|
| 函数只是做打印、提示等操作 | ❌ 可以不用 return |
| 函数要把计算结果交出去用 | 必须用 return |
| 函数是工具型，比如处理数据、转换值 | 推荐 return |
三、常用的内置函数
1. len() —— 获取长度
作用：
返回字符串、列表、元组、字典等可迭代对象的长度。
底层逻辑（简化版）：
其实调用
len(obj)，Python 内部会调用该对象的__len__()方法。
len("hello") → "hello".__len__() → 5示例：
print(len("Python")) # 6
print(len([1, 2, 3, 4])) # 4
print(len({'a': 1})) # 12. range() —— 生成序列
作用：
返回一个不可变的整数序列（不是列表，但可以被迭代）。
底层逻辑：
range(start, stop, step)会返回一个range类型的对象，内部并不立即生成所有值，而是按需计算，更节省内存（惰性序列）。
r = range(0, 10, 2)
print(list(r)) # [0, 2, 4, 6, 8]3. type() —— 查看数据类型
作用：
返回一个对象的类型（类）。
底层逻辑：
type(obj)实际调用的是对象的__class__属性，或者底层PyObject_Type()函数。
type(123) → <class 'int'>
type("hello") → <class 'str'>示例：
print(type(3.14)) # <class 'float'>
print(type([1, 2])) # <class 'list'>4. map() —— 映射函数到序列
作用：
将指定函数作用于可迭代对象中的每个元素，返回一个 map 对象（可迭代）
底层逻辑：
map(func, iterable) → 相当于：for item in iterable: yield func(item)
示例：
def square(x):
return x * x
result = map(square, [1, 2, 3])
print(list(result)) # [1, 4, 9]5. filter() —— 筛选元素
作用：
使用函数过滤序列中符合条件的元素。
底层逻辑：
filter(func, iterable) → 相当于：for item in iterable: if func(item): yield item
示例：
python复制编辑def is_even(n):
return n % 2 == 0
result = filter(is_even, [1, 2, 3, 4])
print(list(result)) # [2, 4]6. sorted() —— 排序（不改变原序列）
作用：
返回一个新排序的列表（原数据不变）
底层逻辑
sorted()` 本质调用的是 `list.sort()` 的 C 实现（Timsort 算法） 支持关键字参数：`key`、`reverse
示例：
nums = [3, 1, 4]
print(sorted(nums)) # [1, 3, 4]
print(sorted(nums, reverse=True)) # [4, 3, 1]7. zip() —— 组合多个序列
作用：
把多个可迭代对象“打包”成元组对，形成新的迭代器。
底层逻辑：
zip(a, b) → 相当于：for i in range(min(len(a), len(b))): yield (a[i], b[i])
示例：
names = ['Tom', 'Jerry']
ages = [18, 20]
print(list(zip(names, ages)))
# [('Tom', 18), ('Jerry', 20)]8. enumerate() —— 带索引的遍历
作用：
给可迭代对象的每个元素加上索引，返回索引和元素的元组。
底层逻辑：
类似于：
def my_enumerate(iterable): index = 0 for item in iterable: yield (index, item) index += 1
示例：
for i, val in enumerate(['a', 'b', 'c']):
print(i, val)输出：
0 a
1 b
2 c✅ 总结表格：
| 函数名 | 功能 | 是否返回迭代器 | 是否常用 | 常配合使用 |
|---|---|---|---|---|
len() |
求长度 | ❌ | ✅ | 任何对象 |
range() |
生成范围序列 | ✅ | ✅ | for 循环 |
type() |
返回类型 | ❌ | ✅ | 调试 |
map() |
映射函数 | ✅ | ✅ | list() |
filter() |
过滤 | ✅ | ✅ | list() |
zip() |
组合元素 | ✅ | ✅ | list() |
enumerate() |
枚举（带索引） | ✅ | ✅ | for 循环 |
9.open() 函数的基本语法
open(file, mode='r', encoding=None)| 参数 | 作用说明 |
|---|---|
file |
文件路径（可以是相对路径或绝对路径） |
mode |
文件打开模式（如 'r'、'w'、'a' 等） |
encoding |
字符编码（通常是 'utf-8'） |
9.1 常用的文件打开模式（mode 参数）
| 模式 | 名称 | 说明 |
|---|---|---|
'r' |
只读模式 | 文件必须存在，否则报错 |
'w' |
写入模式 | 会清空原文件内容，如果文件不存在会自动创建 |
'a' |
追加模式 | 在原文件末尾追加写入，文件不存在也会创建 |
'x' |
独占创建 | 如果文件已存在就报错，否则创建新文件 |
'b' |
二进制模式 | 可加在其他模式后使用（如 'rb'、'wb'）读取/写入二进制文件 |
't' |
文本模式 | 默认值，读取文本文件 |
'+' |
读写模式 | 读写皆可（如 'r+'、'w+'、'a+'） |
9.2open() 常见使用方式和例子
1. 读取文本文件（默认 r 模式）
with open("example.txt", "r", encoding="utf-8") as file:
content = file.read()
print(content)
with ... as是推荐写法，自动关闭文件
file.read()读取全部内容
file.readline()一行一行读取
file.readlines()返回所有行组成的列表
-
写入文本文件（
w模式）
with open("output.txt", "w", encoding="utf-8") as file:
file.write("这是写入的新内容\n")
file.write("第二行内容\n")⚠️ 注意：使用
'w'会清空原内容！
3. 追加内容（a 模式）
with open("log.txt", "a", encoding="utf-8") as file:
file.write("程序运行于 2025-07-11\n")-
读取二进制文件（如图片、音频）
with open("photo.jpg", "rb") as file:
data = file.read()
print(len(data)) # 显示字节数-
写入二进制文件
with open("copy.jpg", "wb") as file:
file.write(data)9.3 文件操作注意事项
| 注意事项 | 说明 |
|---|---|
| 文件操作可能失败 | 所以最好用 try...except 包裹处理 |
建议用 with |
它能自动关闭文件，更安全 |
| 编码要注意 | 建议用 encoding='utf-8'，防止乱码 |
| 文件路径 | 使用原始字符串或 Path 库来避免路径出错 |
9.4 一个完整的示例（读取并复制文本）
try:
with open("input.txt", "r", encoding="utf-8") as f_in:
content = f_in.read()
with open("copy.txt", "w", encoding="utf-8") as f_out:
f_out.write(content)
print("复制成功！")
except FileNotFoundError:
print("文件不存在，请检查路径。")
except Exception as e:
print("发生错误：", e)总结：
| 功能 | 示例 |
|---|---|
| 打开文件 | open("file.txt", "r", encoding="utf-8") |
| 读取内容 | .read()、.readline()、.readlines() |
| 写入内容 | .write("内容") |
| 自动关闭文件 | 使用 with open(...) as f: 块 |
| 二进制操作 | 模式加 'b'：如 'rb'、'wb' |
Agent 垂直技术社区，欢迎活跃、内容共建。
更多推荐
14
0- 0
已为社区贡献8条内容
所有评论(0)