Python 69个 常用 内置函数 之 总结+实例 篇

1.abs()

返回一个数的绝对值

    print(abs(-5))  # 输出 5
    print(abs(5))   # 输出 5

2.dict()

创建一个字典

    my_dict = dict(name="Alice", age=25)
    print(my_dict)  # 输出 {'name': 'Alice', 'age': 25}

3.help()

用于获取关于对象的帮助信息

    help(len)  # 会显示 len 函数的相关帮助文档

# 输出
Help on built-in function len in module builtins:

len(obj, /)
    Return the number of items in a container.

4.min()

返回可迭代对象中的最小值

    numbers = [5, 2, 8, 1]
    print(min(numbers))  # 输出 1

5.setattr()

用于设置对象的属性值

class MyClass:
    pass


obj = MyClass()
obj2 = MyClass()
setattr(obj, 'name', 'Bob')  # 只是obj实例属性
print(obj.name)  # 输出 Bob
print(obj2.name)  # 报错，其他实例和类名都不能访问到

6.all()

如果可迭代对象中的所有元素都为真（或可迭代对象为空），则返回 True，否则返回 False

print(all([True, True]))  # 输出 True
print(all([True, False]))  # 输出 False
# 另一种形式
对象名.all()  # 返回bool值

7.dir()

返回对象的属性和方法列表

    class MyClass:
        def method(self):
            pass

    obj = MyClass()
    print(dir(obj))  # 会列出 obj 的属性和方法

# 输出
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'method']

8.hex()

将一个整数转换为十六进制字符串

    print(hex(255))  # 输出 '0xff'

9.next()

通过迭代器获取下一个元素，迭代器元素只能被访问一次

    it = iter([1, 2, 3])
    print(next(it))  # 输出 1
    print(next(it))  # 输出 2

10.slice()

创建一个切片对象，用于切片操作

my_list = [1, 2, 3, 4, 5]
s = slice(1, 4)
print(my_list[s])  # 输出 [2, 3, 4]
# 等价
print(my_list[1:4])

11.any()

如果可迭代对象中至少有一个元素为真，则返回 True，否则返回 False

    print(any([False, False, True]))  # 输出 True
    print(any([False, False]))  # 输出 False

12.divmod()

同时返回除法的商和余数，以元组的形式

    print(divmod(10, 3))  # 输出 (3, 1)

13.id()

返回对象的唯一标识符（地址）

    x = 5
    print(id(x))  # 输出对象 x 的内存地址

14.object()

通常用于创建自定义类的基类

在 Python 中，所有的类都默认继承自 object 类。如果我们自定义一个类但没有指定父类，那么它默认继承自 object 类

class MyClass(object):
      pass
# 等价
class MyClass():
      pass

15.sorted()

对可迭代对象进行排序并返回一个新的已排序列表

numbers = [5, 1, 3, 2]
print(sorted(numbers))  # 输出 [1, 2, 3, 5]

16.ascii()

返回一个包含对象的可打印表示形式的字符串，类似于 repr()，但只使用 ASCII 字符

print(ascii("Hello, World!"))  # 输出 "'Hello, World!'"
print(ascii(123))  # 输出 '123'
print(ascii([1, 2, 3]))  # 输出 '[1, 2, 3]'

如果对象的表示形式包含非 ASCII 字符，ascii() 函数会使用转义序列来表示这些字符

print(ascii("你好"))  # 输出 "'\\u4f60\\u597d'"

17.enumerate()

将一个可遍历的数据对象（如列表、元组或字符串）组合为一个索引序列，同时列出数据和数据下标。

    fruits = ['apple', 'banana', 'cherry']
    for index, fruit in enumerate(fruits):
        print(index, fruit)
    # 输出 0 apple
    #      1 banana
    #      2 cherry

18.input()

用于从用户获取输入，并返回输入的字符串

    name = input("请输入您的名字：")
    print("您好，" + name)

19.oct()

将一个整数转换为八进制字符串

    print(oct(10))  # 输出 '0o12'  ('012'也正确)

20.staticmethod()

用于将一个方法定义为静态方法。静态方法不依赖于类实例，可以通过类名直接调用。

    class MyClass:
        @staticmethod
        def static_method():
            print("这是一个静态方法")

    MyClass.static_method()

# 输出
这是一个静态方法

21.bin()

将一个整数转换为二进制字符串

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

22.eval()

将字符串作为 Python 表达式进行求值并返回结果

    expression = "2 + 3"
    result = eval(expression)
    print(expression)  # 输出 "2+3"
    print(result)  # 输出 5
    print(2 + 3)  #输出 5

23.int()

将一个值转换为整数

    print(int("10"))  # 输出 10
    print(int(3.14))  # 输出 3  (没有四舍五入)

24.open()

用于打开文件并返回一个文件对象

    file = open("example.txt", "r")
    content = file.read()
    file.close()

25.str()

将一个对象转换为字符串

    num = 123
    print(str(num))  # 输出 '123'

26.bool()

将一个值转换为布尔值（True 或 False）

    print(bool(0))  # 输出 False
    print(bool(1))  # 输出 True

27.exec()

执行储存在字符串或文件中的 Python 语句

    code = "a = 5"
    exec(code)
    print(a)  # 输出 5

28.isinstance()

检查一个对象是否是指定类或其派生类的实例

    class MyClass:
        pass

    obj = MyClass()
    print(isinstance(obj, MyClass))  # 输出 True

29.ord()

返回字符的 Unicode 码点

    print(ord('A'))  # 输出 65

30.sum()

对可迭代对象的元素进行求和

    numbers = [1, 2, 3, 4, 5]
    print(sum(numbers))  # 输出 15

31.bytearray()

返回一个新的字节数组

    ba = bytearray([65, 66, 67])
    print(ba)  # 输出 bytearray(b'ABC')

32.filter()

用于过滤序列，返回一个迭代器，其中包含筛选后的元素

    numbers = [1, 2, 3, 4, 5]
    even_numbers = filter(lambda x: x % 2 == 0, numbers)
    print(list(even_numbers))  # 输出 [2, 4]

33.issubclass()

检查一个类是否是另一个类的子类

    class Parent:
        pass

    class Child(Parent):
        pass

    print(issubclass(Child, Parent))  # 输出 True

34.pow()

计算幂运算

    print(pow(2, 3))  # 输出 8

35.super()

用于在子类中调用父类的方法

    class Parent:
        def method(self):
            print("父类方法")

    class Child(Parent):
        def method(self):
            super().method()
            print("子类方法")

#如果继承自多个类,并且这些类中有同名方法,super()调用时调用的是继承时括号内的第一个父类

    Child().method()

# 输出:
父类方法
子类方法

36.bytes()

用于创建一个字节对象

    b = bytes([65, 66, 67])
    print(b)  # 输出 b'ABC'

37.float()

将一个值转换为浮点数

    print(float("3.14"))  # 输出 3.14
    print(float(5))  # 输出 5.0

38.iter()

返回一个迭代器对象

    numbers = [1, 2, 3]
    iterator = iter(numbers)
    print(next(iterator))  # 输出 1

39.print()

用于输出指定的内容

    print("Hello, World!")

40.tuple()

将一个可迭代对象转换为元组

    print(tuple([1, 2, 3]))  # 输出 (1, 2, 3)

41.callable()

检查一个对象是否可调用（如函数、方法等）

    def my_function():
        pass

    print(callable(my_function))  # 输出 True

42.format()

格式化字符串

    name = "Alice"
    age = 25
    print("My name is {} and I'm {} years old.".format(name, age))

# 输出
My name is Alice and I'm 25 years old.

43.len()

返回对象的长度（如字符串、列表、元组等的元素个数）

    print(len("Hello"))  # 输出 5
    print(len([1, 2, 3]))  # 输出 3

44.property()

用于创建属性

    class MyClass:
        def __init__(self):
            self._value = 0

        def get_value(self):
            return self._value

        def set_value(self, new_value):
            self._value = new_value

        value = property(get_value, set_value)

    obj = MyClass()
    obj.value = 10
    print(obj.value)  # 10

45.type()

返回对象的类型

    print(type(5))  # 输出 <class 'int'>

46.chr()

根据整数码点返回对应的字符

    print(chr(65))  # 输出 'A'

47.frozenset()

创建一个不可变的集合

# 创建一个简单的 frozenset
frozen_set = frozenset([1, 2, 3, 4, 5])
print(frozen_set)  

# 尝试修改 frozenset 会引发错误
try:
    frozen_set.add(6)
except AttributeError as e:
    print("Error:", e)  

48.list()

将一个可迭代对象转换为列表

    print(list("Hello"))  # 输出 ['H', 'e', 'l', 'l', 'o']

49.range()

生成一个整数序列

    for i in range(5):
        print(i)
# 输出
0
1
2
3
4

50.vars()

返回对象的属性和属性值组成的字典

    class MyClass:
        def __init__(self):
            self.name = "Alice"
            self.age = 25

    obj = MyClass()
    print(vars(obj))

# 输出
{'name': 'Alice', 'age': 25}

51.classmethod()

用于将一个方法定义为类方法。类方法可以通过类直接调用，而不需要创建类的实例

    class MyClass:
        @classmethod
        def class_method(cls):
            print("这是一个类方法")

    MyClass.class_method()

52.getattr()

用于获取对象的属性值，如果属性不存在，可以返回默认值

class MyClass:
    def __init__(self):
        self.name = "Alice"
        self.age = 25

obj = MyClass()

# 获取存在的属性
print(getattr(obj, 'name'))  
print(getattr(obj, 'age'))  

# 获取不存在的属性，并提供默认值
print(getattr(obj, 'city', 'Unknown'))  
# 输出
Alice
25
Unknown

53.locals()

返回当前作用域中的局部变量字典

    def my_function():
        x = 10
        y = 20
        print(locals())

    my_function()
# {'x': 10, 'y': 20}

54.repr()

返回一个对象的可打印表示形式，通常用于调试

repr() 函数为不同类型的对象提供了一种用于表示和打印的形式，有助于在调试过程中清晰地查看对象的结构和内容

num = 42
print(repr(num))  # 输出 '42'

lst = [1, 2, 3]
print(repr(lst))  # 输出 '[1, 2, 3]'

class MyClass:
    def __init__(self, value):
        self.value = value

obj = MyClass(10)
print(repr(obj))  # 输出 '<__main__.MyClass object at 0x...>'

55.zip()

将多个可迭代对象组合成一个元组序列

    numbers = [1, 2, 3]
    letters = ['a', 'b', 'c']
    zipped = zip(numbers, letters)
    for pair in zipped:
        print(pair)

(1, 'a')
(2, 'b')
(3, 'c')

56.compile()

将源代码编译为代码对象，可用于动态执行代码

    code = "print('Hello, World!')"
    compiled_code = compile(code, "<string>", "exec")
    exec(compiled_code)

# Hello, World!

57.globals()

返回当前全局作用域中的变量字典

    print(globals())

58.map()

对可迭代对象中的每个元素应用指定的函数，并返回一个新的可迭代对象

    numbers = [1, 2, 3]
    squared_numbers = map(lambda x: x**2, numbers)
    print(list(squared_numbers))

59.reversed()

返回一个反转的迭代器

    numbers = [1, 2, 3]
    reversed_numbers = reversed(numbers)
    print(list(reversed_numbers))
# [3, 2, 1]

60.__import__()

用于动态导入模块

    math_module = __import__('math')
    print(math_module.sqrt(4))

61.complex()

创建一个复数

    num = complex(3, 4)
    print(num)  # 输出 (3+4j)

62.hasattr()

检查对象是否具有指定的属性

    class MyClass:
        def __init__(self):
            self.name = "Alice"

    obj = MyClass()
    print(hasattr(obj, "name"))  # 输出 True

63.max()

返回可迭代对象中的最大值

    numbers = [1, 5, 2]
    print(max(numbers))

64.round()

对数字进行四舍五入

    print(round(3.14159, 2))  # 输出 3.14

65.reload()

重新加载已导入的模块

import my_module  # 假设这是一个自定义模块

# 模块中的初始代码逻辑执行

# 对模块中的代码进行修改

from importlib import reload
reload(my_module)  # 重新加载模块，新的修改将生效

66.delattr()

删除对象的属性

    class MyClass:
        def __init__(self):
            self.name = "Alice"

    obj = MyClass()
    delattr(obj, "name")

class MyClass:
    def __init__(self):
        self.name = "Alice"
        self.age = 25

obj = MyClass()

# 打印初始属性
print(obj.name)  
print(obj.age)  

# 删除属性
delattr(obj, "name")

# 尝试再次访问已删除的属性会报错
try:
    print(obj.name)
except AttributeError as e:
    print("属性已被删除，错误信息：", e)

# 未删除的属性仍可正常访问
print(obj.age)  

67.hash()

返回对象的哈希值

    print(hash("Hello"))
# 2746976938948495924

68.memoryview()

返回给定对象的内存视图，内存视图允许以不同的方式访问和操作对象的内存，而无需复制数据

    numbers = bytearray([1, 2, 3])
    view = memoryview(numbers)
    print(view[0])
# 1

# 创建一个字节数组
data = bytearray(b'Hello World')

# 获取内存视图
mv = memoryview(data)

# 通过内存视图读取数据
print(mv[0])  # 输出 72 (对应 'H' 的 ASCII 值)

# 通过内存视图修改数据
mv[0] = 74  # 将 'H' 改为 'J'
print(data)  # 输出 bytearray(b'Jello World')

# 对整数数组创建内存视图
array = array.array('i', [1, 2, 3, 4, 5])
mv = memoryview(array)
print(mv[0])  # 输出 1

69.set()

创建一个集合

# 直接传入一个列表创建集合
my_set = set([1, 2, 2, 3, 3, 3])
print(my_set)  # 输出 {1, 2, 3}

# 传入多个元素创建集合
another_set = set(1, 4, 5)  # 这种方式会报错，set() 函数接受一个可迭代对象作为参数
# 正确的方式应该是
another_set = set([1, 4, 5])
print(another_set)  # 输出 {1, 4, 5}

# 也可以使用花括号直接创建集合
yet_another_set = {6, 7, 8}
print(yet_another_set)  # 输出 {8, 6, 7}

# 集合的常见操作
my_set.add(4)  # 向集合中添加元素
print(my_set)  # 输出 {1, 2, 3, 4}

my_set.remove(2)  # 从集合中移除元素，如果元素不存在会报错
print(my_set)  # 输出 {1, 3, 4}

my_set.discard(5)  # 从集合中移除元素，如果元素不存在不会报错

# 集合的运算
set1 = {1, 2, 3}
set2 = {2, 3, 4}

# 并集
union_set = set1.union(set2)
print(union_set)  # 输出 {1, 2, 3, 4}

# 交集
intersection_set = set1.intersection(set2)
print(intersection_set)  # 输出 {2, 3}

# 差集
difference_set = set1.difference(set2)
print(difference_set)  # 输出 {1}

内置函数
abs()	dict()	help()	min()	setattr()
all()	dir()	hex()	next()	slice()
any()	divmod()	id()	object()	sorted()
ascii()	enumerate()	input()	oct()	staticmethod()
bin()	eval()	int()	open()	str()
bool()	exec()	isinstance()	ord()	sum()
bytearray()	filter()	issubclass()	pow()	super()
bytes()	float()	iter()	print()	tuple()
callable()	format()	len()	property()	type()
chr()	frozenset()	list()	range()	vars()
classmethod()	getattr()	locals()	repr()	zip()
compile()	globals()	map()	reversed()	__import__()
complex()	hasattr()	max()	round()	reload()
delattr()	hash()	memoryview()	set()