一、内置函数

1.1 查看所有内置函数

内置函数：Python 提供了许多内置函数，这些函数无需导入任何模块即可直接使用。它们涵盖了各种用途，从数学运算到类型检查，再到输入输出操作等。

如何查看内置函数呢？

在Pycharm中，用 import builtins 查看内置函数

eg：

import builtins
print(dir(builtins))

1.2 常见内置函数分类

以下是一些常用的内置函数及其简要说明：

1. 数学运算相关
   • abs(x)：返回数字 x 的绝对值
   • divmod(a, b)：返回 (a // b, a % b)，即商和余数
   • max(iterable, *args, key, default)：返回可迭代对象中的最大值，或者多个参数中的最大值
   • min(iterable, *args, key, default)：返回可迭代对象中的最小值，或者多个参数中的最小值
   • pow(x, y, z)：返回 x 的 y 次幂，如果 z 存在，则返回 x 的 y 次幂对 z 取模的结果
   • round(number, ndigits)：返回四舍五入到 ndigits 位小数的 number
   • sum(iterable, start)：返回可迭代对象中所有元素的总和，start 是可选的起始值
2. 类型转换
   • bool(x)：将 x 转换为布尔值
   • chr(i)：返回 Unicode 码点为 i 的字符
   • int(x, base=10)：将 x 转换为整数，base 指定进制
   • float(x)：将 x 转换为浮点数
   • complex(real, imag)：返回复数 (real + imagj)
   • str(object, encoding='utf-8', errors='strict')：将对象转换为字符串
   • repr(object)：返回对象的官方字符串表示，通常用于调试
   • ord(c)：返回字符 c 的 Unicode 码点
   • hex(x)：将整数 x 转换为十六进制字符串
   • oct(x)：将整数 x 转换为八进制字符串
   • bin(x)：将整数 x 转换为二进制字符串
3. 类型检查
   • isinstance(object, classinfo)：检查对象是否是给定类的实例
   • issubclass(class, classinfo)：检查类是否是另一个类的子类
   • type(object)：返回对象的类型
4. 输入输出
   • input([prompt])：读取用户输入
   • print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)：打印对象到标准输出
5. 内存和对象管理
   • id(object)：返回对象的唯一标识符（内存地址）
   • hash(object)：返回对象的哈希值（如果对象是可哈希的）
6. 迭代器和生成器
   • iter(iterable)：获取迭代器
   • next(iterator, default)：返回迭代器的下一个项目，如果迭代器耗尽则返回 default
7. 可调用对象
   • callable(object)：检查对象是否可调用（如函数、方法、带有 __call__ 方法的对象等）
8. 其他
   • eval(expression, globals=None, locals=None)：执行一个字符串表达式，并返回表达式的值
   • exec(object, globals=None, locals=None)：支持动态执行 Python 代码
   • globals()：返回当前全局符号表的字典
   • locals()：返回当前局部符号表的字典
   • len(object)：返回对象（字符、列表、元组等）的长度或项目数
   • sorted(iterable, key=None, reverse=False)：返回一个新的已排序的列表
   • reversed(seq)：返回一个反转的迭代器
   • slice(start, stop, step)：返回一个表示由 range(start, stop, step) 指定索引集的切片对象
   • super()：返回父类（超类）的一个对象，通常用于调用父类的方法
   • vars([object])：返回对象的 __dict__ 属性，如果没有提供对象，则返回当前局部符号表
   • idle()：启动 Python 的 IDLE（集成开发和学习环境）
   • help([object])：启动内置帮助系统（可选地用于对象）
   • memoryview(obj)：返回给定参数的“内存查看”对象

1.3 常用内置函数介绍

1.3.1 abs（）

abs（）：返回绝对值

eg：

print(abs(-10))  # 输出结果：10

1.3.2 sum（）

sum（）：求和

注意：sum（）函数内需要放除字符串、字典外的可迭代对象（列表、元组、集合）

当你使用 sum() 函数时，请确保你传递的是一个包含数字的可迭代对象，这样函数才能正确地计算总和

如果可迭代对象中包含非数字元素，或者根本就不是一个可迭代对象（比如单个数字或字符串），那么 sum() 函数将无法正常工作，并可能引发错误。

eg1: 列表（List）：包含数字的列表可以直接传递给 sum() 函数

numbers = [1, 2, 3, 4]  
total = sum(numbers)  # total 的值为 10

eg2: 元组（Tuple）：与列表类似，包含数字的元组也可以传递给 sum() 函数

numbers = (1, 2, 3, 4)  
total = sum(numbers)  # total 的值为 10

eg3: 集合（Set）：虽然集合是无序的，但只要它们包含的是数字，也可以传递给 sum() 函数。不过，由于集合不允许重复元素，所以使用集合来计算总和不是最常见的情况

numbers = {1, 2, 3, 4}  # 注意：集合可能不包含所有重复元素  
total = sum(numbers)  # total 的值取决于集合中的实际元素，可能是 1+2+3+4=10，但如果有重复则会被去除

eg4: 字符串（String）：字符串中的元素是字符，它们不是数字，因此不能相加。尝试对字符串使用 sum() 会导致类型错误

# 这将引发 TypeError  
text = "1234"  
total = sum(text)  # 错误

eg5:字典（Dictionary）：字典中的元素是键值对，它们不是单一的数字，因此也不能直接相加。虽然你可以对字典中的值（如果它们是数字）进行求和，但你需要先提取这些值  

# 正确的做法是先提取字典的值，然后求和  
data = {'a': 1, 'b': 2, 'c': 3}  
total = sum(data.values())  # total 的值为 6

1.3.3 min & max（） 

min（）：求最小值

max（）：求最小值

print(min(4,1,8))  # 输出结果：1
print(max(4,1,8))  # 输出结果：8
# tips:比绝对值大小
print(max(-9,3,4,key=abs))   
# 输出结果：-9 ,-9的绝对值为最大，传入了求绝对值函数，则参数就会先求绝对值再取较大者

1.3.4 zip（）

zip（）：函数是一个内置函数，用于将多个可迭代对象（如列表、元组、字符串等）打包成一个元组的迭代器。如果各个可迭代对象的元素个数不一致，则返回的列表长度与最短的对象相同，利用 * 操作符，可以将元组解压为列表。

eg：

li = [1,2,3]
li2 = ['a','b']
print(zip(li,li2))  # 输出结果：<zip object at 0x000002C76F875188>

zip 函数的取出方式：

方法一：通过 for 循环

eg：

li = [1,2,3]
li2 = ['a','b']
print(zip(li,li2))  # 输出结果：<zip object at 0x000002C76F875188>
for i in zip(li,li2):
    print(i)
    print(type(i))  # 如果元素个数不一致，就按照长度最短的返回
# 输出结果：
# (1, 'a')
# <class 'tuple'>
# (2, 'b')
# <class 'tuple'>

 方法二：转换成列表打印

li = [1,2,3]
li2 = ['a','b']
print(list(zip(li,li2)))  # 输出结果：[(1, 'a'), (2, 'b')]   # 转换成列表打印
# 注意：必须是可迭代对象才能转换成列表打印
# print(list(zip(li,3)))  # 存在非可迭代对象，报错

1.3.5 map（） 

map（）：可以对可迭代对象中的每一个元素进行映射，分别去执行，简单来说就是对象中的每一个元素都会去执行这个函数

map（func，iter1）：

func---自己定义的函数

iter1---要放进去的可迭代对象

eg：

li = [1,2,3]
def funa(x):
    return x * 5
mp = map(funa,li)   # 将列表映射后的值储存到mp中
print(mp)  # 输出结果：<map object at 0x000002B26B630048>

map（）函数的取出方式和zip（）函数类似，同样也有两种方式：

方式一：通过 for 循环

eg：

li = [1,2,3]
def funa(x):
    return x * 5
mp = map(funa,li)   # 将列表映射后的值储存到mp中
print(mp)  # 输出结果：<map object at 0x000002B26B630048>
for i in mp:
    print(i)
# 输出结果：5  10  15

方式二：转换成列表打印

eg：

li = [1,2,3]
def funa(x):
    return x * 5
mp = map(funa,li)   # 将列表映射后的值储存到mp中，只用写函数名，不要加上（）
print(list(mp))  # 输出结果：[5, 10, 15]

1.3.6 reduce（）

reduce 函数是一个高阶函数，通常用于对可迭代对象中的元素进行累积计算（即逐步合并成一个单一结果）。它位于 functools 模块中，因此需要先从该模块导入

reduce函数的基本语法如下：

from functools import reduce  # 需要先导包
  
reduce(function, sequence)

• function：一个二元函数，即接受两个参数的函数。这个函数会对可迭代对象中的元素进行累积计算
• sequence：序列，可迭代对象

下面是一些使用 reduce 函数的示例：

eg1：计算列表中所有数字的和

from functools import reduce  
  
numbers = [1, 2, 3, 4, 5]  
  
# 定义一个二元函数，用于相加  
def add(x, y):  
    return x + y  
  
# 使用 reduce 计算和  
total = reduce(add, numbers)  
print(total)  # 输出：15

eg2：计算列表中所有数字的乘积

from functools import reduce  
  
numbers = [1, 2, 3, 4, 5]  
  
# 定义一个二元函数，用于相乘  
def multiply(x, y):  
    return x * y  
  
# 使用 reduce 计算乘积  
product = reduce(multiply, numbers)  
print(product)  # 输出：120

eg3：使用 lambda 表达式简化代码

from functools import reduce  
  
numbers = [1, 2, 3, 4, 5]  
  
# 使用 lambda 表达式计算和  
total = reduce(lambda x, y: x + y, numbers)  
print(total)  # 输出：15  
  
# 使用 lambda 表达式计算乘积  
product = reduce(lambda x, y: x * y, numbers)  
print(product)  # 输出：120

 eg4：使用初始值：有时，我们希望在累积计算中使用一个初始值。例如，计算字符串列表中所有字符串的连接，并在前面添加一个特定的前缀。

from functools import reduce  
  
strings = ["Hello", " ", "World", "!"]  
  
# 使用 reduce 连接字符串，并指定初始值 "Prefix:"  
concatenated = reduce(lambda x, y: x + y, strings, "Prefix:")  
print(concatenated)  # 输出：Prefix: Hello World!

二、拆包

2.1 基本含义

在 Python 中，"拆包"（unpacking）通常指的是将可迭代对象（如列表、元组、集合或字符串等）中的元素赋值给多个变量的过程。这个过程可以通过多种方式实现，包括使用星号（*）操作符、多重赋值以及函数返回值的解包等。

2.2 使用星号（*）操作符拆包

星号操作符可以将可迭代对象中的元素解包到多个变量中，或者将它们收集到一个新的列表中

eg:

# 将列表中的元素拆包到多个变量中  
a, b, c = [1, 2, 3]  
print(a, b, c)  # 输出: 1 2 3  
  
# 将元组中的元素拆包到一个新的列表中  
t = (4, 5, 6)  
*rest = t  
print(rest)  # 输出: [4, 5, 6]

在此例子中，*rest 将元组 t 中的所有元素解包到一个名为 rest 的新列表中

2.3 多重赋值拆包 

这是最直接和常见的拆包方式，即将可迭代对象中的元素直接赋值给多个变量

eg：

# 多重赋值拆包  
x, y, z = 7, 8, 9  
print(x, y, z)  # 输出: 7 8 9

2.4 函数返回值的拆包

当函数返回多个值时（实际上返回的是一个元组），可以使用拆包来将这些值分别赋值给多个变量

# 定义一个返回多个值的函数  
def get_coordinates():  
    return 10, 20  
  
# 拆包函数返回值  
lat, lon = get_coordinates()  
print(lat, lon)  # 输出: 10 20

2.5 在循环中使用拆包

在循环中，可以使用拆包来同时迭代多个可迭代对象

# 使用 zip 和拆包同时迭代两个列表  
list1 = ['a', 'b', 'c']  
list2 = [1, 2, 3]  
  
for char, num in zip(list1, list2):  
    print(char, num)  
# 输出:  
# a 1  
# b 2  
# c 3

在此例子中，zip 函数将 list1 和 list2 中的元素配对成一个新的迭代器，然后循环中的拆包操作将这些配对分别赋值给 char 和 num

2.6 注意事项

1. 拆包时，可迭代对象中的元素数量必须与要赋值的变量数量相匹配，否则会引发 ValueError

2. 如果可迭代对象中的元素多于变量数量，则多余的元素将被忽略。如果少于变量数量，则未赋值的变量将引发 ValueError（在 Python 3 中），或者在 Python 2 中，未赋值的变量将被设置为 None（但这通常不是推荐的做法，因为 Python 2 已经不再维护）