详细介绍Python内置函数②（日常使用）

详细介绍Python内置函数和方法②（日常使用）

pop函数

pop()是Python**列表（list）**的一个方法，用于删除并返回指定索引位置的元素。

pop()方法可以接受一个可选的参数，即要删除的元素的索引位置。如果不指定索引位置，默认会删除并返回列表中的最后一个元素。

示例代码：

fruits = ['apple', 'banana', 'orange', 'grape']
removed_fruit = fruits.pop(1)
print(removed_fruit)  # 输出结果为'banana'
print(fruits)  # 输出结果为['apple', 'orange', 'grape']

numbers = [1, 2, 3, 4, 5]
removed_number = numbers.pop()
print(removed_number)  # 输出结果为5
print(numbers)  # 输出结果为[1, 2, 3, 4]

在上述示例中，fruits.pop(1)删除并返回了列表 fruits 中索引位置为1的元素，也就是’banana’。最后，fruits 中的元素变为 ['apple', 'orange', 'grape']。而numbers.pop()删除并返回了列表 numbers 中的最后一个元素，也就是5。最后，numbers 中的元素变为 [1, 2, 3, 4]。

需要注意的是，如果指定的索引位置超出了列表的范围，pop()方法会抛出 IndexError 异常。

除了删除元素外，pop()方法还可以通过索引位置获取列表中的元素。例如，可以使用 element = list_name.pop(index) 的方式获取列表 list_name 中索引位置为 index 的元素，并将其赋值给变量 element。

numbers = [1, 2, 3, 4, 5]
element = numbers.pop(2)
print(element)  # 输出结果为3
print(numbers)  # 输出结果为[1, 2, 4, 5]

以上就是pop()方法的介绍，它是用于删除并返回列表中指定索引位置的元素的常用方法。需要注意的是，pop()方法会修改原始列表，同时也会返回被删除的元素。

remove函数

remove(): 用于删除列表中第一个匹配给定值的元素，如果列表中不存在该元素，则会抛出 ValueError 异常。

示例代码：

fruits = ['apple', 'banana', 'orange', 'grape']
fruits.remove('banana')
print(fruits)  # 输出结果为['apple', 'orange', 'grape']

在上述示例中，remove()方法删除了列表 fruits 中的第一个匹配字符串’banana’的元素，并返回修改后的列表['apple', 'orange', 'grape']。

需要注意的是，如果列表中存在多个匹配的元素，remove()方法只会删除第一个匹配的元素。

del函数

del: 用于删除指定索引位置的元素或者整个列表。

示例代码：

fruits = ['apple', 'banana', 'orange', 'grape']
del fruits[1]
print(fruits)  # 输出结果为['apple', 'orange', 'grape']

del fruits[:]  # 删除整个列表
print(fruits)  # 输出结果为[]

在上述示例中，del关键字删除了列表 fruits 中的索引位置为1的元素，并返回修改后的列表 ['apple', 'orange', 'grape']。另外，del fruits[:]删除整个列表，使其为空列表[]。

clear函数

clear(): 用于删除列表中的所有元素。

示例代码：

fruits = ['apple', 'banana', 'orange', 'grape']
fruits.clear()
print(fruits)  # 输出结果为[]

在上述示例中，clear()方法删除了列表 fruits 中的所有元素，使其变为空列表[]。

import方法

在Python中，import关键字用于引入模块或者模块中的特定函数、类等。通过使用import关键字，可以在当前的Python脚本中使用其他模块提供的功能。

有多种使用import的方法，下面介绍其中几种常见的方式：

1. 引入整个模块：

   import module_name
   

   这种方式会将整个module_name模块导入到当前的命名空间中。例如，可以使用import math来导入Python标准库中的math模块，从而可以使用math模块中的各种数学函数和常量。

2. 使用import并给模块起别名：

   import module_name as alias
   

   这种方式可以给要导入的模块指定一个别名，以便在代码中更方便地引用。例如，可以使用import numpy as np来将numpy模块导入并指定别名为np，这是使用numpy模块的一种常见做法。

3. 从模块中导入指定函数或变量：

   from module_name import function_name, variable_name
   

   这种方式可以从指定的模块中导入特定的函数或变量，并将其直接引入到当前的命名空间中，而不需要通过模块名进行访问。例如，可以使用from math import sqrt, pi来导入math模块中的sqrt()函数和pi变量。

4. 导入模块中的所有函数和变量：

   from module_name import *
   

   这种方式会将指定模块中的所有函数和变量直接导入到当前的命名空间中，而不需要通过模块名进行访问。但是这种方式可能会引起命名冲突或者不必要的命名空间污染，因此不推荐在实际开发中广泛使用。

需要注意的是，模块的导入通常放在脚本文件的开头，以便在后续的代码中可以直接使用导入的模块或其功能。

sum函数

​ 在Python中，sum()用于计算可迭代对象（如列表、元组等）中所有元素的总和。它接受一个可迭代对象作为参数，并返回该可迭代对象中所有元素的总和。

sum()函数的语法如下所示：

pythonCopy Codesum(iterable, start=0)

其中，iterable是要求和的可迭代对象，start是可选参数，表示求和的初始值，默认为0。

下面是一些使用sum()函数的例子：

1. 求和整数列表：

   enumbers = [1, 2, 3, 4, 5]
   total = sum(numbers)
   print(total)  # 输出结果为15
   

2. 求和浮点数列表：

   prices = [9.99, 5.49, 3.79, 2.99]
   total = sum(prices)
   print(total)  # 输出结果为22.26
   

3. 求和包含元组的列表：

   sales = [(100, 0.25), (50, 0.15), (30, 0.1)]
   total = sum(quantity * price for quantity, price in sales)
   print(total)  # 输出结果为37.5
   

需要注意的是，sum()函数对于字符串列表或其他非数字类型的可迭代对象会引发 TypeError 异常，因为它无法将非数字类型相加。

sort函数

​ 在Python中，sort()是一个列表（list）的内置方法，用于对列表中的元素进行排序。它可以按升序（默认）或降序方式排列列表中的元素，并直接修改原始列表。

sort()方法的语法如下所示：

list.sort(key=None, reverse=False)

其中，key参数是可选的，用于指定一个函数，根据该函数的返回值对列表元素进行排序。reverse参数也是可选的，如果为 True，则按降序方式排序，默认为 False，按升序方式排序。

下面是一些使用sort()方法的例子：

1. 对整数列表进行升序排序：

   numbers = [3, 2, 1, 4, 5]
   numbers.sort()
   print(numbers)  # 输出结果为[1, 2, 3, 4, 5]
   

2. 对字符串列表进行降序排序：

   words = ['hello', 'world', 'python', 'programming']
   words.sort(key=len, reverse=True)
   print(words)  # 输出结果为['programming', 'python', 'hello', 'world']
   

   这里使用了 key 参数和 reverse 参数。将 key 指定为 len 表示按字符串长度排序，而将 reverse 设置为 True 表示按降序排序。

3. 对元组列表按照第二个元素进行升序排序：

   items = [('apple', 3), ('banana', 2), ('pear', 4), ('orange', 1)]
   items.sort(key=lambda x: x[1])
   print(items)  # 输出结果为[('orange', 1), ('banana', 2), ('apple', 3), ('pear', 4)]
   

   这里使用了匿名函数 lambda 表达式作为 key 参数，按元组的第二个元素排序。

需要注意的是，sort() 方法直接修改原始列表，如果需要保留原始列表的顺序，则可以使用 sorted() 内置函数进行排序，并返回一个新列表。

另外，在对包含不同类型的元素的列表进行排序时，需要注意确保所有元素类型相同或具有可比性，否则会引发 TypeError 异常。例如，无法对包含字符串和整数的列表进行排序，因为它们的类型不同。

enumerate函数

enumerate 是一个内置函数，它可以用于遍历一个可迭代对象（如列表、元组、字符串等），并返回索引和对应的值。

以下是 enumerate 函数的基本语法：

pythonenumerate(iterable, start=0)

• iterable：表示要遍历的可迭代对象，如列表、元组、字符串等。
• start（可选）：表示索引的起始值，默认为 0。

enumerate 函数返回一个迭代器，每次迭代都会返回一个包含索引和对应值的元组。我们可以通过解构赋值的方式将索引和对应值分别赋给变量。

以下是一个示例：

pythonfruits = ['apple', 'banana', 'orange']

for index, value in enumerate(fruits):
    print(f"Index: {index}, Value: {value}")

输出结果将会是：

Index: 0, Value: apple
Index: 1, Value: banana
Index: 2, Value: orange

在这个例子中，我们使用 enumerate 函数遍历列表 fruits，并输出每个元素的索引和对应的值。

需要注意的是，索引默认从 0 开始，但你也可以通过设置 start 参数来指定起始值。例如，如果你想从索引 1 开始，可以这样使用：

pythonfruits = ['apple', 'banana', 'orange']

for index, value in enumerate(fruits, start=1):
    print(f"Index: {index}, Value: {value}")

输出结果将会是：

Index: 1, Value: apple
Index: 2, Value: banana
Index: 3, Value: orange

这是 enumerate 函数的基本用法，它非常方便地提供了索引和对应值的遍历方式。

min函数

在Python中，min()函数也是一个内置函数，用于比较多个值并返回最小值。min()函数可以接受可迭代对象（如列表、元组等）作为参数，也可以接受多个单独的值作为参数。

以下是使用min()函数的一些示例：

1. 比较两个数字：

pythona = 10
b = 5
min_val = min(a, b)  # 返回较小的值，即5

1. 比较列表中的元素：

pythonmy_list = [4, 2, 7, 1, 9]
min_val = min(my_list)  # 返回列表中的最小值，即1

1. 比较多个参数的值：

pythonval1 = 15
val2 = 8
val3 = 12
min_val = min(val1, val2, val3)  # 返回最小的值，即8

需要注意的是，当比较字符串时，min()函数将返回按字典顺序最小的字符串。

此外，min()函数还提供了一个可选的key参数，用于指定比较的依据。例如，可以使用lambda表达式或函数来定义自定义的比较规则。

下面是一个使用key参数的示例，按字符串长度比较：

pythonmy_list = ["apple", "banana", "orange"]
min_val = min(my_list, key=lambda x: len(x))  # 返回长度最小的字符串，即"apple"

总之，min()函数是一个灵活且方便的工具，在Python中用于比较多个值并返回最小值。它提供了简洁和可读性强的代码编写方式，适用于各种场景。

表示无穷大

可以使用float(‘inf’)表示一个无穷大。直接赋值给变量即可。

定义一个二维列表

要定义一个二维列表，你可以使用列表嵌套的方式。在Python中，可以使用方括号（[]）来创建列表，并在其中嵌套其他列表来形成二维结构。

下面是两种定义二维列表的常见方法：

1. 使用列表推导式：

matrix = [[element for element in row] for row in rows]

在这个例子中，rows 是包含每一行元素的列表，element 表示每个元素。通过列表推导式，我们可以将每一行的元素提取出来，并放到一个新的列表中，从而得到一个二维列表 matrix。

例如，要定义一个3x3的二维列表，可以使用以下代码：

matrix = [[0, 1, 2], [3, 4, 5], [6, 7, 8]]

1. 使用嵌套的列表赋值：

matrix = [[None] * num_columns for _ in range(num_rows)]

在这个例子中，num_rows 和 num_columns 是表示行数和列数的整数。我们使用了列表复制和循环来创建一个包含空值的二维列表 matrix。

例如，要定义一个3x3的二维列表，可以使用以下代码：

matrix = [[None] * 3 for _ in range(3)]

这样就定义了一个初始值为 None 的3x3二维列表。

无论使用哪种方法，都可以通过索引来访问和修改二维列表中的元素。例如，要访问二维列表中的第一行第二列的元素，可以使用 matrix[0][1]。

定义一个链表结构

 class ListNode:
     def __init__(self, val=0, next=None):
         self.val = val
         self.next = next

初始化

 dummy_head=ListNode(0,head)
 dummy_head=ListNode(next=head)