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)]

三个细节:

  1. 长短不一致以最短的为准,多余的直接丢掉

  2. 想按最长的来,用 itertools.zip_longest(a, b, fillvalue=None)

  3. 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 才为 TrueTrue and False → False
or有一边为 True 就为 TrueTrue 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)              # None

None 不是 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")            # 3

eval / 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 += 1
nonlocal

告诉函数:我要改外层(但不是全局)的变量

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重复执行
循环elseelse循环没被 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: # errorif 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() 返回 Nonea = 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 []

参考文章

  1. AI

  2. Python文档

暂无评论

none
暂无评论...