掘金后端 ( ) • 2024-04-15 13:26

内置函数是指那些随Python环境提供，可以直接使用的函数，无需进行任何额外的导入（import）操作。这些函数是Python标准库的一部分，可以在任何Python程序中直接调用。

Python的内置函数包括但不限于：

数据类型转换函数，如 int(), float(), str(), list(), tuple(), dict()。
数学相关函数，如 abs(), min(), max(), sum(), round()。
迭代相关函数，如 range(), len(), map(), filter(), enumerate(), zip(), sorted(), reversed()。
输入输出函数，如 print(), input(), open()。
对象和属性相关函数，如 type(), isinstance(), getattr(), setattr(), hasattr(), dir().
其他实用函数，如 help(), eval(), exec(), globals(), locals()。

输入输出函数

print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)

将对象打印到文本流（默认为标准输出）。
sep 参数定义对象间的分隔符，默认为空格。
end 参数定义输出后附加的字符串，默认为换行符。

print("Hello, World!", "How are you?", sep=", ", end="!\n")
# Hello, World!, How are you?!

input(prompt)：

显示提示信息，并读取用户的输入作为字符串返回。

name = input("Enter your name: ")
print("Hello", name)

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)：

打开文件并返回相应的文件对象。

with open('example.txt', 'r') as file:
	content = file.read()
print(content)

迭代相关函数

len(s)

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

my_list = [1, 2, 3, 4]
print(len(my_list))  # 输出: 4

range(start, stop[, step])：

生成一个从start开始到stop结束，步长为step的数字序列。

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

sorted(iterable, *, key=None, reverse=False) 用于对各种可迭代对象（如列表、元组、字典等）进行排序，并返回一个新的排好序的列表，原始输入不会被修改。支持自定义排序逻辑，并且可以实现升序或降序排序。

函数参数：

iterable: 需要排序的可迭代对象。
key (可选): 一个只接受一个参数的函数，用于从每个元素中提取比较键（例如，key=str.lower、key=len）。默认值为 None，表示直接比较元素。
reverse (可选): 一个布尔值。如果设置为 True，则列表元素将被降序排列，默认为 False，表示升序排序。

# 升序排序
nums = [3, 1, 4, 1, 5, 9, 2]
print(sorted(nums))  # 输出: [1, 1, 2, 3, 4, 5, 9]

# 字符串升序排序
words = ['banana', 'apple', 'cherry']
print(sorted(words))  # 输出: ['apple', 'banana', 'cherry']

key 参数允许你指定一个函数，该函数将在每个元素上调用，其返回值将作为排序的依据。

# 按字符串长度排序
words = ['banana', 'pie', 'Washington', 'book']
print(sorted(words, key=len))  # 输出: ['pie', 'book', 'banana', 'Washington']

# 忽略大小写排序
words = ['banana', 'Apple', 'cherry']
print(sorted(words, key=str.lower))  # 输出: ['Apple', 'banana', 'cherry']

通过设置 reverse=True，可以实现降序排序。

nums = [3, 1, 4, 1, 5, 9, 2]
print(sorted(nums, reverse=True))  # 输出: [9, 5, 4, 3, 2, 1, 1]

可以同时使用 key 和 reverse 参数来实现更复杂的排序逻辑。

words = ['banana', 'pie', 'Washington', 'book']
# 按长度降序排序
print(sorted(words, key=len, reverse=True))  # 输出: ['Washington', 'banana', 'book', 'pie']

sorted() 函数的灵活性和强大功能使其成为 Python 中处理排序任务的重要工具。通过合理使用 key 和 reverse 参数，几乎可以实现任何排序逻辑。

enumerate(iterable, start=0)

返回一个枚举对象。iterable中的元素以(index, value)形式返回，索引从start开始。

for index, value in enumerate(["a", "b", "c"]):
	print(index, value)

zip(*iterables)：用于将多个可迭代对象中的对应元素打包成一个个元组，然后返回由这些元组组成的迭代器。这个函数在处理并行数据时尤其有用，比如同时遍历两个列表、字典或任何可迭代对象。

zip函数的基本语法如下：

zip(*iterables)

*iterables：一个或多个可迭代对象。

返回值是一个迭代器，每次迭代返回一个元组，包含了输入的每个可迭代对象中的对应元素。

示例1：基础示例

numbers = [1, 2, 3]
letters = ['a', 'b', 'c']

zipped = zip(numbers, letters)

for item in zipped:
    print(item)

# 输出：
# (1, 'a')
# (2, 'b')
# (3, 'c')

这个示例中，zip函数将numbers和letters列表中的对应元素打包成元组。

示例2：处理不同长度的可迭代对象

当zip函数处理长度不同的可迭代对象时，它会停止于最短的输入序列。多出来的元素将被忽略。

numbers = [1, 2]
letters = ['a', 'b', 'c', 'd']

zipped = zip(numbers, letters)

for item in zipped:
    print(item)

# 输出：
# (1, 'a')
# (2, 'b')

示例3：与*操作符解压序列

zip函数与*操作符结合使用可以用于解压序列，即将打包的元组序列解开为多个可迭代对象。

zipped = zip([1, 2, 3], ['a', 'b', 'c'])

numbers, letters = zip(*zipped)

print(numbers)  # 输出：(1, 2, 3)
print(letters)  # 输出：('a', 'b', 'c')

注意事项

当输入的可迭代对象长度不同时，zip将在最短的可迭代对象耗尽时停止迭代，如果需要处理不同长度的序列并保留所有元素，可以考虑使用itertools.zip_longest。
zip返回的是一个迭代器，迭代器只能被消费一次。如果你需要多次遍历结果或者需要列表操作，如索引访问，可以将迭代器转换为列表或元组。

map(function, iterable, ...)：

对iterable中的每个元素应用function。

def square(n):
    return n ** 2
nums = [1, 2, 3, 4]
squared = map(square, nums)
print(list(squared))

filter(function, iterable)：

构造一个迭代器，仅包含使function(item)为True的元素。

nums = [1, 2, 3, 4, 5, 6]
evens = filter(lambda x: x % 2 == 0, nums)
print(list(evens))

对象和属性相关函数

type(object)

返回对象的类型。

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

isinstance(object, classinfo)：

检查object是否是classinfo的实例。

isinstance(1,int)
# True
a='asdd'
isinstance(a.str)
# True
isinstance(a,(str,int,float))
# True

getattr(object, name[, default]), setattr(object, name, value), hasattr(object, name)：

获取、设置或检查对象的属性。

class Person:
	name = "John"

p = Person()
print(getattr(p, 'name'))  # 输出: John
setattr(p, 'age', 30)
print(hasattr(p, 'age'))   # 输出: True

dir([object])：

不带参数时，返回当前作用域中的名称列表；带参数时，返回object的有效属性列表。

print(dir([]))  # 列出列表的所有属性和方法

id(object)：

可以获取变量存储的对象地址

a={'a':111}
b=1
c=[1,4,6]
print(id(a))
print(id(b))
print(id(c))

数据类型转换函数

类型转换函数：int(x), float(x), str(x)

将x转换为整数、浮点数或字符串。

print(int("123"))       # 输出: 123
print(float("123.45"))  # 输出: 123.45
print(str(123))         # 输出: "123"

数学函数

abs(x) 返回数x的绝对值。参数x可以是整数或浮点数。

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

pow(x, y[, z]) 返回x的y次幂；如果提供了可选的z，则返回x的y次幂后对z取模的结果，即pow(x, y) % z。

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

round(number[, ndigits]) 四舍五入number到ndigits指定的精度。ndigits可以是负数。

print(round(3.14159, 2))  # 输出: 3.14
print(round(123.456, -2))  # 输出: 100

divmod(a, b) 接受两个非复数参数a和b，返回一个包含商和余数的元组(a // b, a % b)。

print(divmod(7, 2))  # 输出: (3, 1)

max(iterable, *[, key, default]) / max(arg1, arg2, *args[, key]) 返回集合中的最大值或者两个及以上参数中的最大值。

print(max([1, 2, 3, 4]))  # 输出: 4
print(max(1, 2, 3, 4))  # 输出: 4

min(iterable, *[, key, default]) / min(arg1, arg2, *args[, key]) 返回集合中的最小值或者两个及以上参数中的最小值。

print(min([1, 2, 3, 4]))  # 输出: 1
print(min(1, 2, 3, 4))  # 输出: 1

sum(iterable[, start]) 计算iterable的总和。如果提供了start，会加到总和中。

print(sum([1, 2, 3, 4]))  # 输出: 10
print(sum([1, 2, 3, 4], 10))  # 输出: 20

bool函数

any()函数：检查可迭代对象中是否至少有一个元素为True。如果是，则返回True；否则返回False。
```
print(any([False, False, True]))  # 输出: True
print(any([False, 0, 0.0]))  # 输出: False
```
all()函数：检查可迭代对象中的所有元素是否都为True。如果是，则返回True；否则返回False。
```
print(all([True, 1, 3 > 2]))  # 输出: True
print(all([True, 0, 1]))  # 输出: False
```

其他实用函数

help([object])

调用内置的帮助系统。

help(print)  # 显示print函数的帮助信息

eval(expression, globals=None, locals=None)

执行一个字符串表达式，并返回表达式的值。

result = eval("3 + 5")
print(result)  # 输出: 8