python的一些内置函数的介绍

1.isinstance 使用说明

        isinstance 是 Python 内置函数，用于检查一个对象是否属于某个类（或类的子类）。其语法为：

isinstance(object, class_or_tuple)

举例说明：

isinstance(frame, np.ndarray)

• 检查 frame 是否是 np.ndarray（NumPy 数组）的实例。
• 目的是确保输入的数据类型正确，避免后续操作因类型错误崩溃。

 同样是检查数据类型，isinstance与type的不同：

①isinstance 会考虑类的继承关系。例如：

class MyArray(np.ndarray): pass
obj = MyArray()
print(isinstance(obj, np.ndarray))  # True
print(type(obj) == np.ndarray)      # False

• isinstance 能正确识别子类，而 type() 严格匹配类型。

②isinstance 可接受类型元组 ：

isinstance(frame, (np.ndarray, list))  # 检查是否是 NumPy 数组或列表

2. Python 字典的 get() 方法

        Python 字典的 get() 方法是处理键值对数据时的重要工具，其核心功能是安全地获取键对应的值，避免因键不存在导致的程序崩溃。下面是介绍说明：

①基本语法：

value = dict.get(key, default=None)

• key：要查找的键（必需参数）。
• default：键不存在时的默认返回值（可选参数，默认为 None）。

person = {"name": "Alice", "age": 25}
print(person.get("name"))       # 输出：Alice
print(person.get("salary"))     # 输出：None
print(person.get("salary", 0))  # 输出：0

 ②与方括号访问（dict[key]）的关键区别

• dict[key] 在键不存在时抛出 KeyError 异常。
• get() 方法在键不存在时返回 None 或自定义默认值，避免程序中断。

person = {"name": "Alice", "age": 25}
# 不安全的访问方式
try:
    salary = person["salary"]
except KeyError:
    salary = 0  # 需要额外处理异常

# 安全的访问方式
salary = person.get("salary", 0)  # 一行代替异常处理

 get() 方法通过提供安全的键值访问机制，显著提升代码的健壮性和可读性。

3.hasattr()

        hasattr() 是一个用于 动态检查对象是否拥有特定属性或方法 的内置函数。它在代码中起到 防御性编程 的作用，尤其是在处理可能存在差异的对象结构时非常有用。

 ①基本语法

hasattr(object, 'attribute_name')

 返回 True（如果 object 拥有名为 'attribute_name' 的属性或方法），否则返回 False。 

• 核心作用：

  • 避免 AttributeError 异常：防止因对象无指定属性导致程序崩溃。
  • 兼容性处理：灵活应对对象结构的变化（如依赖库的版本升级导致属性名变更）。

②对比示例 

不安全的写法（直接调用 plot()）

annotated = results.plot()  # 如果 results 没有 plot()，抛出 AttributeError

 安全的写法（使用 hasattr()）

if hasattr(results, 'plot'):
    annotated = results.plot()
else:
    annotated = results.orig_img  # 降级处理

4.enumerate(iterable, start=0)

        enumerate() 是一个用于 为可迭代对象添加索引 的内置函数，它会将输入的序列（如列表、元组、字符串等）转换为一个 索引-值对 的枚举对象（惰性生成）。其核心用途是在遍历过程中同时获取元素的 位置（索引）和值。

①参数说明

参数名	类型	必填	默认值	说明
iterable	可迭代对象	是	—	支持任何可迭代对象（如列表、元组、字符串、文件对象等）
start	整数	否	0	起始索引值，可自定义（例如设置为 1，索引从 1 开始计数）

 ②基本用法

fruits = ["apple", "banana", "cherry"]
#①遍历列表并获取索引与值
# 默认起始索引为 0
for index, fruit in enumerate(fruits):
    print(f"索引 {index}: {fruit}")

# 输出：
# 索引 0: apple
# 索引 1: banana
# 索引 2: cherry

#② 自定义起始索引
# 起始索引设为 1（适用于人类可读的场景，如序号显示）
for idx, fruit in enumerate(fruits, start=1):
    print(f"第 {idx} 个水果: {fruit}")

# 输出：
# 第 1 个水果: apple
# 第 2 个水果: banana
# 第 3 个水果: cherry

#③直接转换为列表查看枚举结果
enum_list = list(enumerate(fruits, start=10))
print(enum_list)
# 输出: [(10, 'apple'), (11, 'banana'), (12, 'cherry')]

enumerate() 是 Python 中提升循环可读性和效率的关键工具，适用于需要同时访问元素索引和值的场景。其核心优势在于：

1. 代码简洁性：避免手动管理索引变量。
2. 灵活性：支持自定义起始索引。
3. 兼容性：适配所有可迭代对象。

5. zip(*iterables) 

         zip() 用于将 多个可迭代对象 的元素按位置配对打包，返回一个惰性生成的迭代器。每个元素是一个元组，包含来自各个输入可迭代对象的同一位置的元素。

①基本语法

        合并列表元素

names = ["Alice", "Bob", "Charlie"]
ages = [25, 30, 28]

# 将姓名和年龄按位置配对
paired = zip(names, ages)
print(list(paired))  
# 输出: [('Alice', 25), ('Bob', 30), ('Charlie', 28)]

         不同长度的可迭代对象

letters = ["A", "B", "C"]
numbers = [1, 2]

# 输出长度由最短的输入决定（此处为 numbers）
result = list(zip(letters, numbers))  
# 输出: [('A', 1), ('B', 2)]

         解包（反向操作）利用 * 运算符解包已压缩的数据：

zipped = [("A", 1), ("B", 2)]
letters, numbers = zip(*zipped)
print(letters)  # ('A', 'B')
print(numbers)  # (1, 2)

 ②进阶技巧

        填充默认值处理不等长序列 使用 itertools.zip_longest（需导入）：

zip_longest() 以最长的输入序列为基准，缺失值填充 None 或自定义值

from itertools import zip_longest

nums = [1, 2]
letters = ["A", "B", "C"]

filled = zip_longest(nums, letters, fillvalue="N/A")
print(list(filled))  
# 输出: [(1, 'A'), (2, 'B'), (None, 'C')]

         批量操作元素 对多列数据进行逐元素计算：

prices = [10.5, 20.3, 15.0]
quantities = [2, 5, 3]

totals = [p * q for p, q in zip(prices, quantities)]
# 输出: [21.0, 101.5, 45.0]

 6.filter(function, iterable)

        filter() 是 Python 的内置函数，用于从可迭代对象（如列表、元组等）中 筛选满足条件的元素，生成一个新的迭代器。其语法为： 

filter(function, iterable)

• function：过滤条件函数，接受一个参数并返回布尔值（True 保留元素，False 过滤元素）。若为 None，则默认保留 iterable 中为真值的元素。
• iterable：待处理的可迭代对象（如列表、生成器等）。
• 返回值：Python 3 返回 filter 迭代器对象，需通过 list() 或循环转换为具体数据结构；Python 2 直接返回列表。

举例：筛选正数 

numbers = [-2, -1, 0, 1, 2]
positive = filter(lambda x: x > 0, numbers)
print(list(positive))  # 输出：[1, 2]

 7.map()

         map() 函数是一个强大的内置工具，用于 批量处理可迭代数据。它通过将指定函数应用到每个元素上，生成新结果序列，常用于简化循环操作并提升代码可读性。

 ①基本语法

map(function, iterable, *iterables)

• function：对元素进行处理的函数（可以是内置函数、lambda表达式或自定义函数）。
• iterable：一个或多个可迭代对象（如列表、元组）。若提供多个，函数需接收相应数量的参数。
• *iterables 是 map() 的可变参数，允许传入多个可迭代对象（如列表、元组、生成器等）本质上还是iterable，但是是为了说明iterable可传递多个可迭代对象。
• 返回值：Python 3 返回迭代器（需用 list() 或循环获取具体值），Python 2 直接返回列表。

# 将列表中的字符串转为整数
str_nums = ["3", "5", "9"]
int_nums = list(map(int, str_nums))  # [3, 5, 9]

# 计算两个列表中对应位置的和
list1 = [1, 2, 3]
list2 = [4, 5, 6]
sums = list(map(lambda x, y: x + y, list1, list2))  # [5, 7, 9]

下面这个例子  结合其他函数式工具（如 filter）构建处理流水线：

# 筛选偶数后平方
nums = [1, 2, 3, 4, 5]
processed = map(
    lambda x: x ** 2, 
    filter(lambda x: x % 2 == 0, nums)
)
print(list(processed))  # [4, 16]