内置函数是指那些随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()。

输入输出函数

1. 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?!

1. input(prompt)：

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

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

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

迭代相关函数

1. len(s)

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

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

1. range(start,stop[,step])：

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

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

1. 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 参数，几乎可以实现任何排序逻辑。

1. enumerate(iterable,start=0)

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

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

1. 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返回的是一个迭代器，迭代器只能被消费一次。如果你需要多次遍历结果或者需要列表操作，如索引访问，可以将迭代器转换为列表或元组。

1. map(function,iterable,...)：

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

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

1. filter(function,iterable)：

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

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

对象和属性相关函数

1. type(object)

• 返回对象的类型。

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

1. isinstance(object,classinfo)：

• 检查 object是否是 classinfo的实例。

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

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

1. dir([object])：

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

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

1. id(object)：

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

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

数据类型转换函数

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

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

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

数学函数

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

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

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

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

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

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

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

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

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

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

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

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

其他实用函数

1. help([object])

• 调用内置的帮助系统。

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

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

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

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