综述由AI生成Python 日常高频写法涵盖数字处理、字符串操作、函数定义、数据结构、面向对象编程及常用工具模块。文章详细列举了 60 个内置函数与核心概念，包括进制转换、ASCII 互转、布尔检查、排序求和、闭包与非局部变量、类方法与元类等。通过代码示例展示了 abs、bin、chr、all、any、sorted、lambda、slice、property 等函数的实际应用，并补充了对象序列化与文件操作技巧。内容旨在帮助开发者快速查阅与复习 Python 核心语法，提升编码效率。
abs(-6) # 输出：6
bin(10) # 输出：'0b1010'
oct(9) # 输出：'0o11'
hex(15) # 输出：'0xf'
chr(65) # 输出：'A'
ord('A') # 输出：65
所有元素都为真，返回 True，否则为 False。
all([1, 0, 3, 6]) # 输出：False
all([1, 2, 3]) # 输出：True
至少有一个元素为真返回 True，否则 False。
any([0, 0, 0, []]) # 输出：False
([, , ])
测试一个对象是 True 还是 False。
bool([0, 0, 0]) # 输出：True (非空列表视为真)
bool([]) # 输出：False
bool([1, 0, 1]) # 输出：True
创建一个复数。
complex(1, 2) # 输出：(1+2j)
分别取商和余数。
divmod(10, 3) # 输出：(3, 1)
将一个整数或数值型字符串转换为浮点数。
float(3) # 输出：3.0
# float('a') 会抛出 ValueError
int(x, base=10)，x 可能为字符串或数值，将 x 转换为一个普通整数。如果参数是字符串，那么它可能包含符号和小数点。如果超出了普通整数的表示范围，一个长整数被返回。
int('12', 16) # 输出：18
pow(3, 2, 4) # 3 的 2 次方 除以 4 取余，输出：1
round(10.0222222, 3) # 输出：10.022
round(10.05, 1) # 输出：10.1
i = 3
print(1 < i < 3) # False
print(1 < i <= 3) # True
s = "apple"
bytes(s, encoding='utf-8') # 输出：b'apple'
str(100) # 输出：'100'
str([]) # 输出：'[]'
str(tuple()) # 输出：'()'
将字符串编译成 Python 能识别或可执行的代码，也可以将文字读成字符串再编译。
s = "print('helloworld')"
r = compile(s, "<string>", "exec") # s 编译为字节代码对象
exec(r) # 输出：helloworld
s = "1 + 3 + 5"
eval(s) # 输出：9
格式化输出字符串，format(value, format_spec) 实质上是调用了 value 的 __format__(format_spec) 方法。
print("i am {0}, age{1}".format("tom", 18)) # 输出：i am tom,age18
a = [1, 4, 2, 3, 1]
sorted(a, reverse=True) # 输出：[4, 3, 2, 1, 1]
a = [{'name': 'xiaoming', 'age': 18, 'gender': 'male'},
{'name': 'xiaohong', 'age': 20, 'gender': 'female'}]
sorted(a, key=lambda x: x['age'], reverse=False)
# 输出：[{'name': 'xiaoming', ...}, {'name': 'xiaohong', ...}]
a = [1, 4, 2, 3, 1]
sum(a) # 输出：11
sum(a, 10) # 输出：21 (初始值为 10)
关键词 nonlocal 常用于函数嵌套中，声明变量为非局部变量；如果不声明，i+=1 表明 i 为函数 wrapper 内的局部变量，因为在 i+=1 引用时，i 未被声明，所以会报 UnboundLocalError 错误。
import time
def excepter(f):
i = 0
t1 = time.time()
def wrapper():
try:
f()
except Exception as e:
nonlocal i
i += 1
print(f'{e.args[0]}: {i}')
t2 = time.time()
if i == n:
print(f'spending time:{round(t2-t1,2)}')
return wrapper
先回答为什么要有 global，一个变量被多个函数引用，想让全局变量被所有函数共享。有的伙伴可能会想这还不简单，这样写：
i = 5
def f():
print(i)
def g():
print(i)
f()
g()
f 和 g 两个函数都能共享变量 i，程序没有报错，所以他们依然不明白为什么要用 global。 但是，如果我想要有个函数对 i 递增，这样：
def h():
i += 1
h()
此时执行程序，出错了！抛出异常：UnboundLocalError，原来编译器在解释 i+=1 时会把 i 解析为函数 h() 内的局部变量，很显然在此函数内，编译器找不到对变量 i 的定义，所以会报错。global 就是为解决此问题而被提出，在函数 h 内，显式地告诉编译器 i 为全局变量，然后编译器会在函数外面寻找 i 的定义，执行完 i+=1 后，i 还为全局变量，值加 1：
i = 0
def h():
global i
i += 1
h()
print(i) # 输出：1
def swap(a, b):
return b, a
print(swap(1, 0)) # 输出：(0, 1)
def f():
print('i\'m f')
def g():
print('i\'m g')
[f, g][1]() # 如果是 [f,g][0]()，返回 i'm f
# 输出：i'm g
创建函数对象的 list，根据想要调用的 index，方便统一调用。
list(range(10, -1, -1)) # [10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0] 从大到小的排列必须用 -1 控制
Python 五类参数：位置参数，关键字参数，默认参数，可变位置或关键字参数的使用。
def f(a, *b, c=10, **d):
print(f'a:{a},b:{b},c:{c},d:{d}')
默认参数 c 不能位于可变关键字参数 d 后。 调用 f:
f(1, 2, 5, width=10, height=20)
# a:1,b:(2, 5),c:10,d:{'width': 10, 'height': 20}
可变位置参数 b 实参后被解析为元组 (2,5);而 c 取得默认值 10; d 被解析为字典。 再次调用 f:
f(a=1, c=12)
# a:1,b:(),c:12,d:{}
a=1 传入时 a 就是关键字参数，b,d 都未传值，c 被传入 12，而非默认值。 注意观察参数 a，既可以 f(1)，也可以 f(a=1) 其可读性比第一种更好，建议使用 f(a=1)。如果要强制使用 f(a=1)，需要在前面添加一个*号:
def f(*, a, **b):
print(f'a:{a},b:{b}')
此时 f(1) 调用，将会报错：TypeError: f() takes 0 positional arguments but 1 was given 只能 f(a=1) 才能 OK。 说明前面的*发挥作用，它变为只能传入关键字参数，那么如何查看这个参数的类型呢？借助 python 的 inspect 模块：
from inspect import signature
for name, val in signature(f).parameters.items():
print(name, val.kind)
# a KEYWORD_ONLY
# b VAR_KEYWORD
可看到参数 a 的类型为 KEYWORD_ONLY，也就是仅仅为关键字参数。 但是，如果 f 定义为：
def f(a, *b):
print(f'a:{a},b:{b}')
查看参数类型：
for name, val in signature(f).parameters.items():
print(name, val.kind)
# a POSITIONAL_OR_KEYWORD
# b VAR_POSITIONAL
可以看到参数 a 既可以是位置参数也可是关键字参数。
cake1 = list(range(5, 0, -1))
cake1 # [5, 4, 3, 2, 1]
b = cake1[1:10:2]
b # [4, 2]
再生成一个序列：
from random import randint
cake2 = [randint(1, 100) for _ in range(100)]
d = cake2[1:10:2]
# d 为切片结果
你看，我们使用同一种切法，分别切开两个容器 cake1,cake2。后来发现这种切法极为经典，又拿它去切更多的容器对象。 那么，为什么不把这种切法封装为一个对象呢？于是就有了 slice 对象。 定义 slice 对象极为简单，如把上面的切法定义成 slice 对象：
perfect_cake_slice_way = slice(1, 10, 2)
cake1_slice = cake1[perfect_cake_slice_way]
cake2_slice = cake2[perfect_cake_slice_way]
逆向序列切片，slice 对象一样可行：
a = [1, 3, 5, 7, 9, 0, 3, 5, 7]
a_ = a[5:1:-1]
named_slice = slice(5, 1, -1)
a_slice = a[named_slice]
# a_ 和 a_slice 结果一致
频繁使用同一切片的操作可使用 slice 对象抽出来，复用的同时还能提高代码可读性。
def max_len(*lists):
return max(*lists, key=lambda v: len(v)) # 返回长度最长的列表
r = max_len([1, 2, 3], [4, 5, 6, 7], [8])
print(f'更长的列表是{r}')
lambda 函数返回值，等于 lambda v 冒号后表达式的返回值。
dict() # {}
dict(a='a', b='b') # {'a': 'a', 'b': 'b'}
dict(zip(['a','b'],[1,2]))# {'a': 1, 'b': 2}
dict([('a',1),('b',2)]) # {'a': 1, 'b': 2}
创建一个不可修改的集合。
frozenset([1, 1, 3, 2, 3]) # frozenset({1, 2, 3})
因为不可修改，所以没有像 set 那样的 add 和 pop 方法。
a = [1, 4, 2, 3, 1]
set(a) # {1, 2, 3, 4}
class slice(start, stop[, step])
返回一个表示由 range(start, stop, step) 所指定索引集的 slice 对象，它让代码可读性、可维护性变好。
a = [1, 4, 2, 3, 1]
my_slice_meaning = slice(0, 5, 2)
a[my_slice_meaning] # [1, 2, 1]
i_am_list = [1, 3, 5]
i_am_tuple = tuple(i_am_list)
# (1, 3, 5)
callable(str) # True
callable(int) # True
class Student():
def __init__(self, id, name):
self.id = id
self.name = name
def __repr__(self):
return 'id = '+self.id +', name = '+self.name
xiaoming = Student('001', 'xiaoming')
callable(xiaoming) # False (不可调用)
如果能调用 xiaoming()，需要重写 Student 类的 __call__ 方法：
class Student():
def __init__(self, id, name):
self.id = id
self.name = name
def __repr__(self):
return 'id = '+self.id +', name = '+self.name
def __call__(self):
print('I can be called')
print(f'my name is {self.name}')
t = Student('001', 'xiaoming')
t() # 输出：I can be called / my name is xiaoming
调用对象的 repr 方法，获得该方法的返回值，如下例子返回值为字符串。
class Student():
def __init__(self, id, name):
self.id = id
self.name = name
def __repr__(self):
return 'id = '+self.id +', name = '+self.name
xiaoming = Student(id='1', name='xiaoming')
xiaoming
# id = 1, name = xiaoming
ascii(xiaoming)
# 'id = 1, name = xiaoming'
classmethod 装饰器对应的函数不需要实例化，不需要 self 参数，但第一个参数需要是表示自身类的 cls 参数，可以来调用类的属性，类的方法，实例化对象等。
class Student():
def __init__(self, id, name):
self.id = id
self.name = name
@classmethod
def f(cls):
print(cls)
delattr(xiaoming, 'id')
hasattr(xiaoming, 'id') # False
不带参数时返回当前范围内的变量、方法和定义的类型列表；带参数时返回参数的属性，方法列表。
dir(xiaoming)
# 列出所有属性和方法
class Student():
def __init__(self, id, name):
self.id = id
self.name = name
xiaoming = Student(id='001', name='xiaoming')
getattr(xiaoming, 'name') # 获取 xiaoming 这个实例的 name 属性值
# 'xiaoming'
class Student():
def __init__(self, id, name):
self.id = id
self.name = name
xiaoming = Student(id='001', name='xiaoming')
hasattr(xiaoming, 'name') # True
hasattr(xiaoming, 'address') # False
id(xiaoming) # 输出内存地址
判断 object 是否为类 classinfo 的实例，是返回 true。
class Student():
def __init__(self, id, name):
self.id = id
self.name = name
xiaoming = Student(id='001', name='xiaoming')
isinstance(xiaoming, Student) # True
class undergraduate(Student):
def studyClass(self):
pass
def attendActivity(self):
pass
issubclass(undergraduate, Student) # True
issubclass(object, Student) # False
issubclass(Student, object) # True
如果 class 是 classinfo 元组中某个元素的子类，也会返回 True。
issubclass(int, (int, float)) # True
object 是所有类的基类。
o = object()
type(o) # object
返回 property 属性，典型的用法：
class C:
def __init__(self):
self._x = None
def getx(self):
return self._x
def setx(self, value):
self._x = value
def delx(self):
del self._x
x = property(getx, setx, delx, "I'm the 'x' property.")
使用 python 装饰器，实现与上完全一样的效果代码：
class C:
def __init__(self):
self._x = None
@property
def x(self):
return self._x
@x.setter
def x(self, value):
self._x = value
@x.deleter
def x(self):
del self._x
class type(name, bases, dict) 传入一个参数时，返回 object 的类型：
class Student():
def __init__(self, id, name):
self.id = id
self.name = name
xiaoming = Student(id='001', name='xiaoming')
type(xiaoming) # __main__.Student
type(tuple()) # tuple
xiaoming, xiaohong, xiaozhang 都是学生，这类群体叫做 Student。 Python 定义类的常见方法，使用关键字 class。
class Student(object):
pass
xiaoming, xiaohong, xiaozhang 是类的实例，则：
xiaoming = Student()
xiaohong = Student()
xiaozhang = Student()
创建后，xiaoming 的 __class__ 属性，返回的便是 Student 类。
xiaoming.__class__ # __main__.Student
问题在于，Student 类有 __class__ 属性，如果有，返回的又是什么？
xiaoming.__class__.__class__ # type
哇，程序没报错，返回 type。 那么，我们不妨猜测：Student 类，类型就是 type。 换句话说，Student 类就是一个对象，它的类型就是 type。 所以，Python 中一切皆对象，类也是对象。 Python 中，将描述 Student 类的类被称为：元类。 按照此逻辑延伸，描述元类的类被称为：元元类，开玩笑了~ 描述元类的类也被称为元类。 说对了，type 类一定能创建实例，比如 Student 类了。
Student = type('Student', (), {})
Student # __main__.Student
它与使用 class 关键字创建的 Student 类一模一样。 Python 的类，因为又是对象，所以和 xiaoming，xiaohong 对象操作相似。支持：赋值、拷贝、添加属性、作为函数参数。
StudentMirror = Student # 类直接赋值
Student.class_property = 'class_property' # 添加类属性
hasattr(Student, 'class_property') # True
元类，确实使用不是那么多，也许先了解这些，就能应付一些场合。就连 Python 界的领袖 Tim Peters 都说： '元类就是深度的魔法，99% 的用户应该根本不必为此操心。'
返回一个可以枚举的对象，该对象的 next() 方法将返回一个元组。
s = ["a", "b", "c"]
for i, v in enumerate(s, 1):
print(i, v)
# 1 a
# 2 b
# 3 c
import sys
a = {'a': 1, 'b': 2.0}
sys.getsizeof(a) # 占用字节数
在函数中设定过滤条件，迭代元素，保留返回值为 True 的元素：
fil = filter(lambda x: x > 10, [1, 11, 2, 45, 7, 6, 13])
list(fil) # [11, 45, 13]
返回对象的哈希值，值得注意的是自定义的实例都是可哈希的，list, dict, set 等可变对象都是不可哈希的 (unhashable)。
hash(xiaoming) # 6139638
hash([1, 2, 3]) # TypeError: unhashable type: 'list'
返回对象的帮助文档。
help(xiaoming)
获取用户输入内容。
input() # aa
# 'aa'
使用 iter(obj, sentinel)，返回一个可迭代对象，sentinel 可省略 (一旦迭代到此元素，立即终止)。
lst = [1, 3, 5]
for i in iter(lst):
print(i)
# 1
# 3
# 5
返回文件对象。
fo = open('D:/a.txt', mode='r', encoding='utf-8')
fo.read()
mode 取值表请参考官方文档。
range(stop)
range(start, stop[, step])
生成一个不可变序列：
range(11) # range(0, 11)
range(0, 11, 1)# range(0, 11)
rev = reversed([1, 4, 2, 3, 1])
for i in rev:
print(i)
# 1
# 3
# 2
# 4
# 1
创建一个聚合了来自每个可迭代对象中的元素的迭代器：
x = [3, 2, 1]
y = [4, 5, 6]
list(zip(y, x)) # [(4, 3), (5, 2), (6, 1)]
a = range(5)
b = list('abcde')
[str(y) + str(x) for x, y in zip(a, b)] # ['a0', 'b1', 'c2', 'd3', 'e4']
from operator import add, sub
def add_or_sub(a, b, oper):
return (add if oper == '+' else sub)(a, b)
add_or_sub(1, 2, '-') # -1
对象序列化，是指将内存中的对象转化为可存储或传输的过程。很多场景，直接一个类对象，传输不方便。 但是，当对象序列化后，就会更加方便，因为约定俗成的，接口间的调用或者发起的 web 请求，一般使用 json 串传输。 实际使用中，一般对类对象序列化。先创建一个 Student 类型，并创建两个实例。
class Student():
def __init__(self, **args):
self.ids = args['ids']
self.name = args['name']
self.address = args['address']
xiaoming = Student(ids=1, name='xiaoming', address='北京')
xiaohong = Student(ids=2, name='xiaohong', address='南京')
导入 json 模块，调用 dump 方法，就会将列表对象 [xiaoming,xiaohong]，序列化到文件 json.txt 中。
import json
with open('json.txt', 'w') as f:
json.dump([xiaoming, xiaohong], f, default=lambda obj: obj.__dict__, ensure_ascii=False, indent=2, sort_keys=True)
生成的文件内容，如下：
[
{
"address":"北京",
"ids":1,
"name":"xiaoming"
},
{
"address":"南京",
"ids":2,
"name":"xiaohong"
}
]
本文整理了 Python 开发中常用的 60 个高频写法和内置函数，涵盖数字处理、字符串操作、函数定义、数据结构、面向对象编程及常用工具模块。掌握这些基础用法有助于提升编码效率和代码质量。建议在实际项目中结合具体场景灵活运用，并注意不同版本 Python 之间的兼容性差异。
微信公众号「极客日志V2」，在微信中扫描左侧二维码关注。展示文案：极客日志V2 zeeklog
使用加密算法（如AES、TripleDES、Rabbit或RC4）加密和解密文本明文。 在线工具，加密/解密文本在线工具，online
生成新的随机RSA私钥和公钥pem证书。 在线工具，RSA密钥对生成器在线工具，online
基于 Mermaid.js 实时预览流程图、时序图等图表，支持源码编辑与即时渲染。 在线工具，Mermaid 预览与可视化编辑在线工具，online
随机生成西班牙地址（支持马德里、加泰罗尼亚、安达卢西亚、瓦伦西亚筛选），支持数量快捷选择、显示全部与下载。 在线工具，随机西班牙地址生成器在线工具，online
基于开源反向 Alpha 混合算法去除 Gemini/Nano Banana 图片水印，支持批量处理与下载。 在线工具，Gemini 图片去水印在线工具，online
解析常见 curl 参数并生成 fetch、axios、PHP curl 或 Python requests 示例代码。 在线工具，curl 转代码在线工具，online