Python 日常高频写法与内置函数速查 | 极客日志

PythonAI算法

Python 日常高频写法与内置函数速查

Python 日常高频写法涵盖数字处理、字符串操作、函数定义、数据结构、面向对象编程及常用工具模块。文章详细列举了 60 个内置函数与核心概念，包括进制转换、ASCII 互转、布尔检查、排序求和、闭包与非局部变量、类方法与元类等。通过代码示例展示了 abs、bin、chr、all、any、sorted、lambda、slice、property 等函数的实际应用，并补充了对象序列化与文件操作技巧。内容旨在帮助开发者快速查阅与复习 Python 核心语法，提升编码效率。

静心发布于 2025/2/60 浏览

一、数字

1. 求绝对值

(-)

bin(10)  # 输出：'0b1010'

oct(9)   # 输出：'0o11'

hex(15)  # 输出：'0xf'

chr(65)  # 输出：'A'

ord('A') # 输出：65

all([1, 0, 3, 6]) # 输出：False
all([1, 2, 3])    # 输出：True

any([0, 0, 0, []]) # 输出：False
any([0, 0, 1])     # 输出：True

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('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())   # 输出：'()'

s = "print('helloworld')"
r = compile(s, "<string>", "exec") # s 编译为字节代码对象
exec(r)                               # 输出：helloworld

s = "1 + 3 + 5"
eval(s) # 输出：9

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)

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

i = 5
def f():
    print(i)
def g():
    print(i)
f()
g()

def h():
    i += 1
h()

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(range(10, -1, -1)) # [10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0] 从大到小的排列必须用 -1 控制

def f(a, *b, c=10, **d):
    print(f'a:{a},b:{b},c:{c},d:{d}')

f(1, 2, 5, width=10, height=20)
# a:1,b:(2, 5),c:10,d:{'width': 10, 'height': 20}

f(a=1, c=12)
# a:1,b:(),c:12,d:{}

def f(*, a, **b):
    print(f'a:{a},b:{b}')

from inspect import signature
for name, val in signature(f).parameters.items():
    print(name, val.kind)
# a KEYWORD_ONLY
# b VAR_KEYWORD

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

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 为切片结果

perfect_cake_slice_way = slice(1, 10, 2)
cake1_slice = cake1[perfect_cake_slice_way]
cake2_slice = cake2[perfect_cake_slice_way]

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 结果一致

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}')

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

a = [1, 4, 2, 3, 1]
set(a) # {1, 2, 3, 4}

class slice(start, stop[, step])

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 (不可调用)

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

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'

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) # 输出内存地址

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

issubclass(int, (int, float)) # True

o = object()
type(o) # object

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.")

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

class Student(object):
    pass

xiaoming = Student()
xiaohong = Student()
xiaozhang = Student()

xiaoming.__class__ # __main__.Student

xiaoming.__class__.__class__ # type

Student = type('Student', (), {})
Student # __main__.Student

StudentMirror = Student # 类直接赋值
Student.class_property = 'class_property' # 添加类属性
hasattr(Student, 'class_property') # True

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) # 占用字节数

fil = filter(lambda x: x > 10, [1, 11, 2, 45, 7, 6, 13])
list(fil) # [11, 45, 13]

hash(xiaoming) # 6139638
hash([1, 2, 3]) # TypeError: unhashable type: 'list'

help(xiaoming)

input() # aa
# 'aa'

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

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

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='南京')

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 日常高频写法与内置函数速查

一、数字

1. 求绝对值

2. 进制转化

十进制转换为二进制

十进制转换为八进制

十进制转换为十六进制

3. 整数和 ASCII 互转

十进制整数对应的 ASCII 字符

查看某个 ASCII 字符对应的十进制数

4. 元素都为真检查

5. 元素至少一个为真检查

6. 判断是真是假

7. 创建复数

8. 取商和余数

9. 转为浮点类型

10. 转为整型

11. 次幂（base 为底的 exp 次幂，如果 mod 给出，取余）

12. 四舍五入

13. 链式比较

二、字符串

14. 字符串转字节

15. 任意对象转为字符串

16. 执行字符串表示的代码

17. 计算表达式

18. 字符串格式化

三、函数

19. 排序函数

20. 求和函数

21. nonlocal 用于内嵌函数中

22. global 声明全局变量

23. 交换两元素

24. 操作函数对象

25. 生成逆序序列

26. 函数的五类参数使用例子

27. 使用 slice 对象

28. lambda 函数的动画演示

四、数据结构

29. 转为字典

30. 冻结集合

31. 转为 set 集合类型

32. 转为切片对象

33. 转元组

五、类和对象

34. 是否可调用

35. ascii 展示对象

36. 类方法

37. 动态删除属性

38. 一键查看对象所有方法

39. 动态获取对象属性

40. 对象是否有这个属性

41. 对象内存地址

42. isinstance

43. 父子关系鉴定

44. 所有对象之根

45. 创建属性的两种方式

46. 查看对象类型

47. 元类

六、工具

48. 枚举对象

49. 查看变量所占字节数

50. 过滤器

51. 返回对象的哈希值

52. 一键帮助

53. 获取用户输入

54. 创建迭代器类型

55. 打开文件

56. 创建 range 序列

57. 反向迭代器

58. 聚合迭代器

59. 链式操作

60. 对象序列化

总结

微信扫一扫，关注极客日志

更多推荐文章

相关免费在线工具