Python之关键字和内置函数
记录一下Python的关键字和内置函数,简单记录于此,方便自己查阅。
正文
关键字 ≠ 内置函数
if for def 是关键字,是语言自带的;range zip len print 是内置函数(Built-in Functions),两者别混为一谈:
| 对比 | 关键字(if for def…) | 内置函数(len range zip…) |
|---|---|---|
| 本质 | 语法规则的一部分 | builtins 模块里现成提供的函数 |
| 调用方式 | 不能加括号 | 必须加括号调用 |
| 当变量名 | 直接报 SyntaxError | 允许,但会覆盖原函数(强烈不建议) |
| 数量 | 35 个左右,几乎不变 | 70 个左右,dir(builtins) 可查 |
if = 1 # SyntaxError,关键字不能用
len = 10 # 不报错,但从此 len([1,2]) 就废了,别干
print = 10 # 同理本文用「内置函数」标记出来的,都是可以直接调用的家伙。条件判断
if / elif / else
age = 18
if age >= 18:
print("成年")
elif age >= 12:
print("青少年")
else:
print("儿童")| 关键字 | 作用 |
|---|---|
| if | 如果条件成立,执行这里的代码 |
| elif | 否则如果(可以有多个) |
| else | 以上都不成立时执行(可选) |
常见错误:if 后面忘记加冒号 :;缩进不一致。
match / case / _
Python 3.10+ 的多路选择(类似 switch)
status = 200
match status:
case 200:
print("成功")
case 404:
print("未找到")
case _: # _ 是通配符,相当于 default
print("其他状态")| 关键字 | 作用 |
|---|---|
| match | 对后面的表达式做匹配 |
| case | 匹配某个具体值或模式 |
| _ | 通配符,匹配"其他所有情况" |
比 if-elif-else 更整洁,还能匹配复杂结构(列表、对象等)。
顺带一提:三元表达式
if / else 的缩写写法,一行搞定二选一:
score = 85
level = "及格" if score >= 60 else "不及格"读作:条件成立取前面的值,否则取后面的。别写太长,可读性优先。
循环遍历
for
for fruit in ["苹果", "香蕉", "橙子"]:
print(fruit)
for i in range(5): # 0,1,2,3,4
print(i)内置函数:range —— 生成一串整数
range(5) # 0,1,2,3,4 只有一个参数时,表示 stop
range(1, 6) # 1,2,3,4,5 start, stop
range(0, 10, 2) # 0,2,4,6,8 第三个是步长
range(5, 0, -1) # 5,4,3,2,1 步长可以是负数,倒着来左闭右开:range(1, 6) 不含 6,这是最常见的踩坑点
返回的是 range 对象,不是列表,省内存;要列表就 list(range(5))
判断在不在里面很快:100 in range(10) → False,不用真的生成
内置函数:enumerate —— 循环时顺便拿下标
for i, fruit in enumerate(["苹果", "香蕉"], start=1):
print(i, fruit) # 1 苹果 / 2 香蕉别再写 for i in range(len(列表)) 了,enumerate 才是地道写法。
内置函数:zip —— 把多个序列"拉链式"配对
names = ["张三", "李四", "王五"]
ages = [18, 20]
scores = [90, 85, 88]
for name, age in zip(names, ages):
print(name, age) # 张三 18 / 李四 20(王五被丢掉了)
dict(zip(names, ages)) # {'张三': 18, '李四': 20} 秒变字典
list(zip(names, scores)) # [('张三',90), ('李四',85), ('王五',88)]三个细节:
长短不一致以最短的为准,多余的直接丢掉
想按最长的来,用 itertools.zip_longest(a, b, fillvalue=None)
zip(*数据) 加个星号是"解压",常用来做矩阵转置:
matrix = [[1, 2, 3], [4, 5, 6]]
list(zip(*matrix)) # [(1, 4), (2, 5), (3, 6)]内置函数:reversed / sorted / len
for c in reversed("abc"): # c, b, a 反向迭代
print(c)
sorted([3, 1, 2]) # [1, 2, 3] 返回新列表
sorted([3, 1, 2], reverse=True) # [3, 2, 1]
sorted(["bbb", "a", "cc"], key=len) # ['a', 'cc', 'bbb'] 按长度排
sorted("This is a test".split(), key=str.lower)
len("hello") # 5,序列/字典/集合都能用sorted() 返回新列表;列表.sort() 是原地排序,返回 None。
写 a = a.sort() 会得到 None,经典惨案。
内置函数:iter / next —— 手动控制迭代
nums = iter([10, 20])
next(nums) # 10
next(nums) # 20
next(nums) # 抛 StopIteration(没有下一个了)
next(nums, "没了") # 给个默认值就不报错,返回 "没了"for 循环本质上就是不断调用 next(),只是帮你把 StopIteration 吞掉了。
循环相关内置函数速查
| 内置函数 | 作用 | 备注 |
|---|---|---|
| len(x) | 元素个数 | 字符串、列表、字典、集合都适用 |
| range(a,b,s) | 生成整数序列 | 左闭右开,惰性不占内存 |
| enumerate(x) | 同时拿下标和值 | 推荐替代 range(len(x)) |
| zip(a,b) | 并行遍历多个序列 | 以最短的为准 |
| reversed(x) | 反向迭代 | 返回迭代器,不是列表 |
| sorted(x) | 排序,返回新列表 | 支持 key= 和 reverse= |
| iter(x) | 得到迭代器 | 配合 next() 用 |
| next(it, d) | 取下一个元素 | 可提供默认值 |
| sum(x) | 求和 | 详见「数学运算」 |
| map/filter | 批量转换 / 过滤 | 详见「函数」 |
| all/any | 全为真 / 有一个为真 | 详见「逻辑判断」 |
while
count = 0
while count < 3:
print(count)
count += 1别忘了更新条件,否则会死循环!
| 关键字 | 作用 | 示例 |
|---|---|---|
| break | 立刻跳出整个循环 | 见下例 |
| continue | 跳过这次,进入下一次 | 见下例 |
| else | 循环专属,循环没被 break 才执行 | 见下例 |
for i in range(10):
if i == 5:
break # 碰到 5 就停
print(i) # 输出 0,1,2,3,4
for i in range(5):
if i == 2:
continue # 跳过 2
print(i) # 输出 0,1,3,4
for i in range(3):
print(i)
else:
print("循环正常跑完了,没被中断")这个 else 和 if 里的 else 不是一回事,很多老手都会忽略它。
逻辑判断
and / or / not
x = 7
if x > 0 and x < 10:
print("在范围内")
if x < 0 or x > 100:
print("超出范围")
if not x == 5:
print("x 不是 5")| 关键字 | 含义 | 示例 |
|---|---|---|
| and | 两边都为 True 才为 True | True and False → False |
| or | 有一边为 True 就为 True | True or False → True |
| not | 取反 | not True → False |
| in | 在不在里面? | "a" in "apple" # True(字符串里有没有)3 in [1, 2, 3] # True(列表里有没有) |
| is | 是不是同一个东西?(比地址) | a = Nonea is None # True |
== 比的是值,is 比的是内存地址。一般只在判断 None 时用 is。
补充:小整数(-5 ~ 256)和短字符串会被 Python 缓存复用,所以 a = 1; b = 1; a is b 是 True。
这是实现细节,不要依赖它去比大小,比数值一律用 ==。
内置函数:all / any
批量做逻辑判断,比写一长串 and / or 清爽:
all([True, 1 > 0, "a"]) # True,全部为真才是 True
any([False, 0, ""]) # False,有一个真就是 True
any([False, 0, "hi"]) # True
nums = [2, 4, 6]
all(n % 2 == 0 for n in nums) # True,全是偶数
any(n > 5 for n in nums) # True,有大于 5 的| 内置函数 | 作用 | 类比 |
|---|---|---|
| all(x) | 全部为真才返回 True | 相当于一串 and |
| any(x) | 有一个为真就返回 True | 相当于一串 or |
两个边界记住就行:all([]) 是 True,any([]) 是 False。
布尔与空值
True / False
flag = True
if flag:
print("是真的")None
什么都没有
x = None
print(x) # NoneNone 不是 0,不是空字符串 "",不是空列表 [],它就是"啥也不是"。
内置函数:bool —— 真假判定
bool(x) 就是把任意值转成 True / False,规则很简单:
bool(0) # False
bool("") # False
bool([]) # False
bool(None) # False
bool("0") # True 注意!非空字符串一律是 True
bool([0]) # True 非空列表也是 True会被判为 False 的,只有这么几类:
| 假值 | 说明 |
|---|---|
| False / None | 本身就是"假/空" |
| 0 0.0 0j | 所有数值零 |
| "" [] () {} set() | 空字符串 / 空容器 |
其他一律是 True。所以判断列表非空,写 if 列表: 就够,比 if len(列表) > 0: 更地道。
数据类型与转换
写代码绕不开的"变形"操作。
内置函数:类型转换
int("12") # 12 字符串转整数
int(3.9) # 3 直接截断,不是四舍五入!
int("1010", 2) # 10 按二进制解析
float("3.14") # 3.14
str(123) # '123'
bool(1) # True
list("ab") # ['a', 'b']
list({"a": 1}) # ['a'] 字典转列表只取键
tuple([1, 2]) # (1, 2)
set([1, 1, 2]) # {1, 2} 顺手去重
dict([("a", 1)]) # {'a': 1}
dict(a=1, b=2) # {'a': 1, 'b': 2}
frozenset([1, 2]) # frozenset({1, 2}) 不可变,能当字典的 key
bytes("a", "utf-8") # b'a'
complex(1, 2) # (1+2j)
bin(10) # '0b1010'
oct(8) # '0o10'
hex(255) # '0xff'
ord("A") # 65 字符 → Unicode 码点
chr(65) # 'A' 码点 → 字符| 函数 | 作用 |
|---|---|
| int/float/str/bool | 转整数 / 小数 / 字符串 / 布尔 |
| list/tuple/set/dict | 转列表 / 元组 / 集合 / 字典 |
| frozenset | 转不可变集合 |
| bytes | 转字节(b'...') |
| complex | 复数 |
| bin/oct/hex | 二 / 八 / 十六进制字符串 |
| ord/chr | 字符 ↔ Unicode 码点 |
转换失败会抛 ValueError(int("abc"))或 TypeError,拿不准就套一层 try。
数学运算
| 函数 | 作用 | 示例 |
|---|---|---|
| abs(x) | 绝对值 | abs(-3) → 3 |
| round(x, n) | 四舍五入 | round(3.14159, 2) → 3.14 |
| max(…) | 最大值 | max(3, 1, 2) → 3 |
| min(…) | 最小值 | min([3, 1, 2]) → 1 |
| sum(x) | 求和 | sum([1, 2, 3]) → 6 |
| pow(x, y) | 幂运算 | pow(2, 3) → 8 |
| divmod(a, b) | 同时拿商和余数 | divmod(7, 3) → (2, 1) |
max(["bb", "a"], key=len) # 'bb',按长度比(key 指定比较依据)
sum([1, 2, 3], start=10) # 16,可以带初始值
max(3, 1, 2) # 直接传多个参数也行
max([3, 1, 2]) # 传一个可迭代对象也行
max([]) # 报错!空序列要写 default:max([], default=0)round(2.5) 结果是 2 而不是 3 —— 用的是"银行家舍入",.5 时取最近的偶数。
需要严格四舍五入请用 decimal 模块。
输入输出
| 函数 | 作用 |
|---|---|
| print(…) | 打印到屏幕 |
| input(prompt) | 读一行输入,返回字符串 |
| open(file, mode) | 打开文件 |
| format(x, spec) | 格式化单个值 |
| repr(x) | 返回"官方"字符串表示 |
print("a", "b", sep="-") # a-b sep 改分隔符
print("hi", end="") # 不换行 end 改行尾
age = int(input("年龄:")) # input 一律返回 str,要数字自己转
format(3.14159, ".2f") # '3.14'
f"{3.14159:.2f}" # '3.14' f-string 更常用
open("a.txt", "w", encoding="utf-8")str() 是给人看的,repr() 是给调试/机器看的:
s = "hi"
print(str(s)) # hi
print(repr(s)) # 'hi' 带引号,能一眼看出类型函数
def
def greet(name):
print(f"你好,{name}")return
def add(a, b):
return a + b
result = add(3, 5) # result = 8没有 return 的函数,默认返回 None。
lambda
square = lambda x: x * x
square(5) # 25适合简单操作,复杂逻辑还是用 def。
yield
def count_up():
yield 1
yield 2
yield 3
for n in count_up():
print(n)和 return 不同:yield 会"暂停",下次接着来。
yield from
def nums():
yield from range(3)内置函数:map / filter(函数式三件套)
把函数"批量应用"到一个序列上:
nums = [1, 2, 3, 4]
list(map(lambda x: x * 2, nums)) # [2, 4, 6, 8] 全部转换
list(map(str, nums)) # ['1','2','3','4'] 直接传现成函数
list(filter(lambda x: x % 2 == 0, nums)) # [2, 4] 留下满足条件| 内置函数 | 作用 | 返回 |
|---|---|---|
| map(func, x) | 对每个元素做转换 | 迭代器(惰性) |
| filter(func, x) | 留下 func 为真的元素 | 迭代器(惰性) |
| sorted(x, key=f) | 排序 | 新列表 |
几个要点:
它们返回的是迭代器,只能消费一次,要看结果得 list() 包一层
传 None 也能用:filter(None, [0, 1, "", "a"]) → [1, 'a'],自动过滤假值
reduce 在 Python 3 里被移出内置,要用得 from functools import reduce
逻辑一复杂,用列表推导式比 map/filter 更好读:
[x * 2 for x in nums] # 等价于 map
[x for x in nums if x % 2 == 0] # 等价于 filter内置函数:callable
判断一个东西能不能加括号调用(函数、类、带 call 的对象):
callable(print) # True
callable(len) # True
callable(123) # False类与对象
把数据和功能绑一起
class
class Dog:
def bark(self):
print("汪汪")pass
占位符,啥也不干
class EmptyClass:
pass # 还没想好写啥,先占个位
if True:
pass # 暂时什么都不做内置函数:super —— 调用父类
class Animal:
def speak(self):
print("...")
class Dog(Animal):
def speak(self):
super().speak() # 先干父类的事
print("汪汪")super().init() 在继承里几乎是标配。
内置函数:属性操作四件套
class A:
x = 1
hasattr(A, "x") # True 有没有这个属性
getattr(A, "x") # 1 取属性
getattr(A, "y", 0) # 0 不存在就返回默认值,不报错
setattr(A, "y", 2) # 设置属性
delattr(A, "y") # 删除属性比直接 A.x 的好处:属性名可以是变量,写通用代码时很香。
内置函数:type / isinstance / issubclass
type(1) # <class 'int'>
isinstance(1, int) # True
isinstance(True, int) # True bool 是 int 的子类
issubclass(bool, int) # True
type(True) == int # False type 是"精确匹配"type() 只认精确类型,isinstance() 会把子类算进去,日常推荐 isinstance。
内省与调试
拿不准对象是什么、有什么方法时用这几个:
| 内置函数 | 作用 |
|---|---|
| id(x) | 对象的内存地址(配合 is 理解) |
| type(x) | 对象的类型 |
| isinstance(x, cls) | 是不是某个类型(含子类) |
| dir(x) | 列出对象所有属性和方法 |
| help(x) | 查看帮助文档(交互式下超好用) |
| vars(x) | 对象的 dict,属性字典 |
| hash(x) | 哈希值,能当字典 key 的前提是"可哈希" |
| globals() | 当前全局命名空间的字典 |
| locals() | 当前局部命名空间的字典 |
| eval(s) | 执行字符串表达式并返回值(慎用) |
| exec(s) | 执行字符串形式的代码(慎用) |
dir("") # 看看字符串都有哪些方法
help(str.split) # 查某个方法的用法
hash("abc") # 可哈希;hash([1,2]) 会报错,因为列表可变
vars() # 不传参 ≈ locals()
eval("1 + 2") # 3eval / exec 会执行任意代码,千万别拿用户输入直接喂给它,有注入风险。
异常处理
程序出错了别崩
try / except / finally / raise
try:
result = 10 / 0
except ZeroDivisionError:
print("不能除以零!")
finally:
print("不管怎样我都会执行")主动"扔"一个错误:
raise ValueError("这个值不对劲")| 关键字 | 作用 |
|---|---|
| try | 试试这段代码 |
| except | 如果出错了,走这里 |
| else | 没出错才执行(可选) |
| finally | 不管出没出错,都执行 |
| raise | 主动抛出一个异常 |
try 的 else 分支(和循环 else 一样容易被忽略):
try:
result = 10 / 2
except ZeroDivisionError:
print("除零了")
else:
print("一切正常,结果是", result) # 只有没抛异常才走
finally:
print("收尾")关键字:assert —— 断言
"我断言这事儿肯定成立",不成立就抛 AssertionError:
def divide(a, b):
assert b != 0, "除数不能为 0" # 逗号后面是提示信息
return a / b适合调试和自检,别用它替代正常的参数校验(python -O 运行时断言会被跳过)。
常见内置异常
| 异常 | 什么时候出现 |
|---|---|
| SyntaxError | 语法写错了 |
| IndentationError | 缩进不对 |
| NameError | 用了没定义的变量 |
| TypeError | 类型不对('1' + 1) |
| ValueError | 类型对但值不对(int("a")) |
| IndexError | 下标越界 |
| KeyError | 字典里没这个键 |
| AttributeError | 对象没这个属性 |
| ZeroDivisionError | 除以 0 |
| FileNotFoundError | 文件不存在 |
| StopIteration | 迭代器没下一个了 |
try:
d = {}
print(d["x"])
except KeyError as e: # as 把异常对象接住
print("缺了键:", e)变量作用域
global
告诉函数:我要改全局变量
count = 0
def inc():
global count
count += 1nonlocal
告诉函数:我要改外层(但不是全局)的变量
def outer():
x = 10
def inner():
nonlocal x
x = 20
inner()模块导入
用别人的代码
import / from
import math # 导入整个模块
from os import path # 只导入 path
import numpy as np # as 起个短别名
from os import path as p # 给导入的东西也起别名as 也是关键字,专门用来起别名。
from math import * # 不推荐:污染命名空间,容易覆盖同名变量
if __name__ == "__main__": # 只有直接运行本文件时才执行
main() # 被 import 时不会跑上下文管理
自动收拾烂摊子
with
用完自动清理
with open("test.txt") as f:
content = f.read()
# 文件自动关闭,不用写 f.close()异步编程
同时做好几件事
async / await
import asyncio
async def hello():
await asyncio.sleep(1)
print("你好")
asyncio.run(hello())不是多线程,是协程,适合 I/O 密集型任务(网络请求、文件读写等)。
配套的两个关键字:async with(异步上下文管理)、async for(异步迭代),用法跟普通 with / for 一样,只是用在异步对象上。
删除
del
删掉变量
x = 10
del x
# 再访问 x 会报错del 不只删变量,还能删容器里的东西:
nums = [1, 2, 3]
del nums[0] # [2, 3] 按下标删
del nums[0:2] # [] 切片也能删
d = {"a": 1, "b": 2}
del d["a"] # {'b': 2} 删字典的键
# 对象的属性用 delattr 或 del
del obj.name
delattr(obj, "name")列表删除常用 remove(值) / pop(下标) / clear(),跟 del 各有场景。
总结
关键字小结
| 类别 | 关键字 | 一句话说明 |
|---|---|---|
| 条件 | if elif else | 如果…否则… |
| 模式匹配 | match case _ | 多路选择(3.10+) |
| 循环 | for while break continue | 重复执行 |
| 循环else | else | 循环没被 break 才执行 |
| 逻辑 | and or not | 与或非 |
| 判断 | in is | 在不在、是不是同一个 |
| 布尔/空 | True False None | 真、假、啥也没有 |
| 函数 | def return lambda yield yield from | 定义函数、返回、生成器 |
| 类 | class pass | 定义类、占位 |
| 异常 | try except finally raise | 错误处理 |
| 作用域 | global nonlocal | 变量在哪能用 |
| 模块 | import from as | 导入代码、起别名 |
| 断言 | assert | 断言条件必须成立 |
| 上下文 | with | 自动资源管理 |
| 异步 | async await | 协程 |
| 删除 | del | 删除变量、元素、属性 |
内置函数小结
| 类别 | 内置函数 | 一句话说明 |
|---|---|---|
| 迭代遍历 | len range enumerate zip reversed iter next | 循环里的主力军 |
| 排序转换 | sorted map filter | 排序、批量转换、过滤 |
| 逻辑聚合 | all any bool | 全为真、有为真、真假判定 |
| 类型转换 | int float str bool list tuple set dict | 各种变形 |
| 类型转换+ | frozenset bytes complex bin oct hex ord chr | 进阶变形 |
| 数学运算 | abs round max min sum pow divmod | 常用计算 |
| 输入输出 | print input open format repr | 打印、读输入、开文件、格式化 |
| 类型判断 | type isinstance issubclass callable | 是什么类型、能不能调用 |
| 属性操作 | getattr setattr hasattr delattr super vars | 动态读写属性、调父类 |
| 内省调试 | id dir help hash globals locals eval exec | 查户口(后两个慎用) |
想看完整清单,交互式里敲 dir(builtins),或查官方文档的 Built-in Functions。
注意事项
| 坑 | 说明 | 正确写法 |
|---|---|---|
| 把关键字当变量名 | if = 3 # error | 换个名字:condition = 3 |
| = 和 == 搞混 | if x = 5: # error | if x == 5: |
| is 和 == 混用 | if x is 5: # error(偶尔对,但不严谨) | if x == 5: |
| 忘记缩进 | 代码没缩进 # error | 统一 4 个空格 |
| 死循环 | while True: 里没 break # error | 确保有退出条件 |
| 覆盖内置函数名 | list = [1,2] 之后 list("ab") 就废了 | 别用 list str id type 当变量 |
| sort() 返回 None | a = a.sort() → a 是 None | 用 a = sorted(a) 或直接 a.sort() |
| range 左闭右开 | range(1, 5) 没有 5 | 想要 5 就写 range(1, 6) |
| zip 静默截断 | 两个列表不等长时多余的直接丢 | 用 itertools.zip_longest |
| input 返回字符串 | age = input() 拿到的是 '18' | age = int(input()) |
| 迭代器只能用一次 | map filter zip 的结果消费完就没了 | 需要重复用就 list() 存下来 |
| eval 执行用户输入 | 有代码注入风险 | 用 ast.literal_eval 或自己解析 |
| 可变对象当默认参数 | def f(x=[]): 会累积上次的结果 | def f(x=None): x = x or [] |
参考文章
AI
