Python中的函数

1.map()函数

map() 函数是 Python 内置的高阶函数之一，它接受两个参数：一个是函数，另一个是可迭代对象（如列表、元组等），并返回一个迭代器，其中每个元素是将可迭代对象的元素依次传入函数的返回值。

具体来说，map() 函数的语法如下：

map(function, iterable, ...)

• function：用来处理每个元素的函数，可以是 Python 内置函数或自定义函数。该函数接受一个参数，代表 iterable 中的元素，将其处理后返回结果。注意，如果 function 函数有多个参数，则 map() 函数后续的参数将依次传入该函数；
• iterable：要处理的可迭代对象，如列表、元组等。

实例：

str_list = ["1", "2", "3"]
int_list = list(map(int, str_list))
print(int_list)  # 输出：[1, 2, 3]

在上面的例子中，int() 函数被用作 map() 的第一个参数，将 str_list 中的每个元素都转换为整数（str_list中的每一个元素都作为int函数的参数，传递到函数的内部进行运算）。最终的结果是一个可迭代对象，可以使用 list() 函数将其转换为列表。

另外，map() 函数还支持多个可迭代对象的迭代，当传入多个可迭代对象时，function 函数的参数也需要相应地进行调整。例如：

a = [1, 2, 3]
b = [4, 5, 6]
c = [7, 8, 9]

# 将多个列表对应位置的元素相加
# 取出a,b,c中的元素，作为参数传递到lambda表达式中
result = list(map(lambda x, y, z: x + y + z, a, b, c))
print(result)  # 输出：[12, 15, 18]

在上面的例子中，map() 函数同时迭代了三个列表 a、b 和 c，并将它们对应位置的元素相加。注意，这里的 lambda 函数定义了三个参数，分别对应三个可迭代对象中相同位置的元素。

上述中的lambda表达式同时也可以换成我们自己定义的函数：

a = [1, 2, 3]
b = [4, 5, 6]
c = [7, 8, 9]
def cal(a,b,c):
    return a+b+c
# 将多个列表对应位置的元素相加
result = list(map(cal, a, b, c))
print(result)  # 输出：[12, 15, 18]

2.sorted函数

在Python中，sorted()函数是用于对可迭代对象进行排序的内置函数。它接受一个可迭代对象作为输入，并返回一个排序后的列表。sorted()函数的通用语法如下：

sorted(iterable, *, key=None, reverse=False)

其中，iterable是需要进行排序的可迭代对象，比如列表、元组、集合、字典等等。key是一个用于排序的函数，可以通过它来指定元素进行比较的依据。reverse是一个布尔值参数，用于指定是否按照倒序来排序，默认为False，即升序排序。

下面是几个例子，展示如何使用sorted()函数：

# 对列表进行排序
lst = [5, 2, 8, 1, 3]
sorted_lst = sorted(lst)
print(sorted_lst)  # 输出 [1, 2, 3, 5, 8]

# 对元组进行排序
tpl = (3, 1, 4, 2, 5)
sorted_tpl = sorted(tpl)
print(sorted_tpl)  # 输出 [1, 2, 3, 4, 5]

# 对集合进行排序
s = {3, 1, 4, 2, 5}
sorted_s = sorted(s)
print(sorted_s)  # 输出 [1, 2, 3, 4, 5]

# 对字典进行排序
d = {'a': 5, 'b': 2, 'c': 8, 'd': 1, 'e': 3}
sorted_d = sorted(d.items(), key=lambda x: x[1])
print(sorted_d)  # 输出 [('d', 1), ('e', 3), ('b', 2), ('a', 5), ('c', 8)]

在最后一个例子中，我们使用了key参数，指定按照字典中的值来排序，而不是按照键来排序。key参数接受一个函数作为参数，该函数将被应用到每个元素上，返回值将用作比较依据。在这个例子中，我们使用了一个lambda函数，它返回字典中每个键值对的值。最后，sorted()函数将返回一个由排序后的键值对组成的列表。

3. .items()

在 Python 中，字典（dictionary）是一种由键（key）和对应的值（value）组成的无序的数据集合。.items() 是字典对象（dict）的一个方法，用于返回字典中所有的键值对。

.items() 方法会返回一个由键值对（元组）组成的可迭代对象。其中，每个元组由两个值组成，第一个值为键，第二个值为对应的值。我们可以使用 for 循环迭代这个可迭代对象，逐个访问字典中的所有键值对。

下面是一个使用 .items() 方法的例子：

>>> my_dict = {'a': 1, 'b': 2, 'c': 3}
>>> for key, value in my_dict.items():
...     print(key, value)
...
a 1
b 2
c 3

在这个例子中，my_dict.items() 返回一个由三个元组组成的可迭代对象。在循环中，每次迭代都将一个元组赋值给 key 和 value 变量，然后打印出来。

4. .sort()函数

.sort() 方法只适用于内置的可变序列类型（如 list、bytearray 等），因为排序是在原序列上进行的，会改变原序列本身。而不可变序列类型（如 tuple、string、bytes 等）没有这个方法，因为不能改变原序列。但是，这些不可变序列类型都有一个内置函数 sorted() 可以用来排序，它不改变原序列，而是返回一个排好序的新序列。

在 Python 中，list 的 sort() 方法可以按照特定的规则对列表进行排序。sort() 方法允许传入一些参数来指定排序的规则。

sort() 方法的参数包括：

• reverse：布尔类型，表示是否对列表进行逆序排序，默认为 False。如果设置为 True，列表将按照降序排序。
• key：一个函数，用来指定在排序过程中每个元素进行比较时所用的键（排序关键字），默认为 None。可以指定一个函数来对每个元素进行处理，并返回一个用于比较的值。
  以下是使用 sort() 方法进行排序的示例代码：

# 按照元素长度进行排序
fruits = ["apple", "banana", "orange", "pear"]
fruits.sort(key=len)
print(fruits)  # ["pear", "apple", "banana", "orange"]

# 按照元素长度进行降序排序
fruits.sort(key=len, reverse=True)
# fruits.sort(key=lambda x:len(x),reverse=True)
print(fruits)  # ["banana", "orange", "apple", "pear"]

# 按照元素首字母进行排序
fruits.sort()
print(fruits)  # ["apple", "banana", "orange", "pear"]

# 按照元素末尾字母进行排序
def last_letter(word):
    return word[-1]
fruits.sort(key=last_letter)
print(fruits)  # ["banana", "apple", "pear", "orange"]

在上述示例中，我们使用 sort() 方法对一个字符串列表进行了排序，其中 key 参数被用来指定排序规则。第一个例子按照字符串长度排序，第二个例子按照字符串长度的降序排序，第三个例子按照字符串的字典序排序，第四个例子按照字符串末尾字母进行排序。

注意：.sort函数没有返回值！因此：

x = [1,2,3]
x = x.sort(reverse=True)
print(x)   # None

5.filter函数

在Python中，filter()是一个内置函数，它可以用来筛选序列中的元素，并返回一个迭代器对象。这个迭代器对象只包含使函数返回值为True的元素。

filter()函数的语法如下：

filter(function, iterable)

其中，function是一个函数，它将应用于可迭代对象iterable的每个元素，并根据函数返回的结果来判断是否包含该元素。iterable是一个序列，可以是一个列表、元组、字符串等。

下面是一个简单的例子，它使用filter()函数从一个列表中筛选出所有的偶数：

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

def is_even(x):
    return x % 2 == 0
# 遍历迭代器中的每一个元素，将该元素作为参数传递到函数中进行判断，如果函数的返回值为True的话，那么这个元素满足条件，则将该元素加入到迭代器中。
result = filter(is_even, numbers)
print(list(result))  # 输出 [2, 4, 6, 8, 10]

在这个例子中，is_even()是一个函数，它接受一个参数x并返回一个布尔值，表示该数字是否为偶数。filter()函数使用这个函数来筛选出numbers列表中的偶数，并将结果存储在一个迭代器对象中。最后，list()函数将这个迭代器对象转换为一个列表并输出。

6.reduce函数

reduce() 是 Python 中的一个内置函数，需要从 functools 模块中导入。reduce() 函数用于将一个函数作用在一个序列（Iterable）上，这个函数必须接受两个参数，reduce 把结果继续和序列的下一个元素做累积计算。它的语法如下：

from functools import reduce

reduce(function, sequence[, initial])

参数解释：

function：一个二元操作函数，它必须接受两个参数。用来将序列的前两个元素进行操作，得到的结果再与第三个元素用函数进行操作，以此类推，直到最后一个元素，最终得到一个结果。
sequence：一个序列（可以是列表、元组等），对其进行递归操作。
initial：可选参数，可以为初始值，从而在序列为空时，仍然能够进行递归操作。

下面是一个简单的例子：将列表 [1, 2, 3, 4, 5] 中所有元素相乘。

from functools import reduce

def multiply(x, y):
    return x * y

nums = [1, 2, 3, 4, 5]
result = reduce(multiply, nums)
print(result)
# Output: 120

7.all函数

all() 是 Python 内置函数之一，用于判断可迭代对象中的所有元素是否都为 True。

当传入一个可迭代对象时，all() 会迭代这个对象，如果对象中所有元素都是 True，它就返回 True，否则返回 False。

下面是一个使用 all() 的简单例子：

>>> lst1 = [True, True, False]
>>> lst2 = [True, True, True]
>>> print(all(lst1))
False
>>> print(all(lst2))
True

在上面的例子中，lst1 包含一个 False 元素，所以 all() 返回 False，而 lst2 中所有元素都是 True，因此 all() 返回 True。

需要注意的是，如果传入的可迭代对象为空，all() 也会返回 True，因为这符合 “所有元素都为 True” 的条件。例如：

>>> lst3 = []
>>> print(all(lst3))
True

all() 还可以接收多个参数，用法与接收一个可迭代对象相同。例如：

>>> print(all(True, True, False))
False
>>> print(all(True, True, True))
True

8. dict函数

在Python中，dict函数是用来创建一个字典对象的。该函数可以接受多个参数，其中最常用的是关键字参数。关键字参数是由一组键值对组成的，用来定义字典中的元素。
以下是dict()函数的一些常用参数和说明：

dict()：创建一个空字典。
dict(mapping, **kwargs)：从一个映射对象（比如字典）和关键字参数创建字典。
dict(iterable, **kwargs)：从可迭代对象和关键字参数创建字典。可迭代对象中的每个元素应该是由两个元素组成的元组，第一个元素作为键，第二个元素作为值。
**kwargs：关键字参数，用来定义字典中的元素。每个关键字都是一个键，对应的值是字典中的值。

例如：

# 创建一个空字典
my_dict = dict()
print(my_dict)  # {}

# 创建一个带有初始值的字典
my_dict = dict(a=1, b=2, c=3)
print(my_dict)  # {'a': 1, 'b': 2, 'c': 3}

# 使用列表创建字典
my_dict = dict([('a', 1), ('b', 2), ('c', 3)])
# 换成：my_dict = dict((('a', 1), ('b', 2), ('c', 3)))
print(my_dict)  # {'a': 1, 'b': 2, 'c': 3}

在上述代码中，第一个dict()函数调用创建了一个空字典，第二个dict()函数调用使用了关键字参数创建了一个具有初始值的字典，第三个dict()函数调用使用了一个由元组组成的列表创建了一个字典。

9. .split()函数

在Python中，.split()函数是用于将字符串按照指定的分隔符进行分割，并返回分割后的字符串列表。默认情况下，分隔符是空格字符（空格、制表符、换行符等）。该函数可以通过传入不同的参数来实现不同的功能。下面是该函数的基本用法和参数说明：

string.split(sep=None, maxsplit=-1)

参数说明：
sep：指定分隔符。默认为None，表示使用空格字符作为分隔符。
maxsplit：指定最大分割次数。默认为-1，表示分割所有的子字符串。

例如，假设有一个字符串"apple,orange,banana"，我们可以使用.split()函数将它按照逗号进行分割，并得到一个列表：

>>> fruits = "apple,orange,banana"
>>> fruit_list = fruits.split(',')
>>> print(fruit_list)
['apple', 'orange', 'banana']

下面的例子：

# 按照空格划分，因为连续出现了多个空格，因此每两个空格之间会划分，就形成了空的字符串!
>>> text = "Hello     world!"
>>> words = text.split(' ')
>>> print(words)
['Hello', '', '', '', '', '', 'world!']

结果中出现了多个空字符串。为了去除这些空字符串，可以使用列表推导式来去除空字符串：

>>> words = [word for word in text.split(" ") if word]
>>> print(words)
['Hello', 'world!']

ps：其实上面的情况中，如果我们想一步到位的话，我们可以调用split函数的时候，直接用默认的空格分隔符，即：text.split() 即可！

输出一行数字，并将数字存储到列表中！

num = list(map(int,input().split()))  # 输入：1 2 3 4  5
print(num)        # [1, 2, 3, 4, 5]

10. defaultdict 函数

defaultdict是Python中的一个数据结构，在使用时可以设置一个默认值，如果访问一个不存在的key，会自动创建对应的value，而不会抛出KeyError异常。defaultdict的定义方式和字典一样，只不过需要传入一个可调用对象作为默认值，可以是函数、类或lambda函数等。下面是一个示例：

from collections import defaultdict

# 使用int作为默认值
d = defaultdict(int)
print(d['a']) # 0
print(d['b']) # 0

# 使用lambda函数作为默认值
d = defaultdict(lambda: 'default')
print(d['a']) # 'default'
print(d['b']) # 'default'

在以上代码中，第一个示例中的defaultdict(int)创建了一个默认值为0的字典，如果访问不存在的key，则返回默认值0。第二个示例中的defaultdict(lambda: ‘default’)创建了一个默认值为字符串"default"的字典，同样，如果访问不存在的key，则返回默认值"default"。

11.range函数

range函数返回迭代器。
注意：迭代器一定是可迭代对象，而可迭代对象不一定是迭代器。

for i in range(10):
    print(i,end=' ')
    # 0 1 2 3 4 5 6 7 8 9



for i in range(1,4):
    print(i,end=' ')
    # 1 2 3 

for i in range(1,4,2):
    print(i,end=' ')
    # 1 3 

12.abs函数

abs() 函数可以用于计算复数的模（绝对值）。对于复数 z = a + bj，其中 a 和 b 是实数部分和虚数部分，abs(z) 将返回复数的模，即 sqrt(a^2 + b^2)。

以下是 abs() 函数用于复数的示例：

complex_num = 3 + 4j
abs_val = abs(complex_num)
print(abs_val)  # 输出: 5.0
# 

13. print函数

print(1,2,3)  # 1 2 3
print(1,2,3,sep=',')  # 1,2,3
print(1,2,3,sep=',',end='hello')  # 1,2,3hello

14. .find函数

在 Python 中，find() 是字符串对象的内置方法，用于查找子字符串在原始字符串中的第一个出现位置。它返回子字符串在原始字符串中的索引值，如果找不到则返回 -1。

以下是使用 find() 方法的示例：

sentence = "Hello, world! How are you?"

# 查找子字符串
index = sentence.find("world")
print(index)  # 输出: 7

# 指定起始位置和结束位置
index = sentence.find("o", 5, 10)
print(index)  # 输出: 8

# 查找不存在的子字符串
index = sentence.find("Python")
print(index)  # 输出: -1

# 指定起始的位置：
str1 = "Runoob example....wow!!!"
str2 = "exam"
print(str1.find(str2, 5))   # 7

15.可变数据类型的索引

左闭右开！

li = [1,2,3,4,5]
print(li[2:-2])  # [3]
str = '1,2,3,4,5'
print(str[2:-1]) # 2,3,4,
print(str[2:4])  # 2,

16. .format函数

在 Python 中，.format() 是字符串对象的内置方法，用于格式化字符串。它允许我们将变量、表达式或其他值插入到字符串中的占位符位置。

name = "Alice"
age = 25

# 格式化字符串
greeting = "Hello, my name is {} and I am {} years old.".format(name, age)
print(greeting)  # 输出: Hello, my name is Alice and I am 25 years old.

# 格式化数字
pi = 3.14159
formatted_pi = "The value of pi is {:.2f}".format(pi)
print(formatted_pi)  # 输出: The value of pi is 3.14

# 格式化多个值
item = "apple"
quantity = 5
price = 1.25
order = "I want to buy {} {}s for {:.2f} dollars.".format(quantity, item, quantity * price)
print(order)  # 输出: I want to buy 5 apples for 6.25 dollars.

s = 'PYTHON'
str = "{0:10}".format(s)  # 10表示不足10位补足10位
# 如果需要结果右边对齐，str = "{0:>10}".format(s)
print(len(str))
print(str)

name = 'Alice'
age = 25
formatted_string = "My name is {0} and I am {1} years old.".format(name, age)
print(formatted_string)  # 输出: "My name is Alice and I am 25 years old."

.format函数

# .format是一个函数，这里相当于是将这个函数名赋值给变量formatter
formatter = 'good {0}'.format 
print(list(map(formatter, ['morning'])))  # ['good morning']

17. pow函数

在 Python 中，pow() 函数用于计算一个数的指数幂。

pow(x, y) 接受两个参数 x 和 y，其中 x 是底数，y 是指数。函数返回 x 的 y 次幂的结果。

示例用法：

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

在上述示例中，pow(2, 3) 计算了 2 的 3 次幂，结果为 8。

pow() 函数还支持一个可选的参数 z，用于指定计算幂后取模的值。即，pow(x, y, z) 将返回 (x ** y) % z 的结果。

示例用法：

result = pow(2, 3, 5)
print(result)  # 输出: 3

在上述示例中，pow(2, 3, 5) 计算了 2 的 3 次幂，然后取模 5，结果为 3。

需要注意的是，pow() 函数返回的结果的数据类型与输入参数的数据类型相关。例如，如果输入参数是整数，则返回的结果也是整数；如果输入参数是浮点数，则返回的结果也是浮点数。

18. int函数

字符串参数和基数参数：将指定基数的字符串转换为整数。基数用于指定字符串的进制，可以是 2~36 之间的整数。

num = int("1010", 2)  # 将二进制字符串转换为整数
print(num)  # 输出: 10

19. eval函数

在 Python 中，eval() 函数用于将字符串作为表达式进行求值，并返回表达式的结果。

eval() 函数接受一个字符串参数，并将该字符串作为有效的 Python 表达式进行求值。它可以执行数学运算、调用函数、访问变量等操作。返回值是表达式求值的结果。

以下是 eval() 函数的常见用法示例：

1. 数学表达式求值：

result = eval("2 + 3 * 4")
print(result)  # 输出: 14

2. 使用变量和函数：

x = 5
y = 10
result = eval("x + y")
print(result)  # 输出: 15

def square(n):
    return n ** 2

result = eval("square(3)")
print(result)  # 输出: 9

3. 访问内置函数和模块：

result = eval("len('hello')")
print(result)  # 输出: 5

import math
result = eval("math.sqrt(16)")
print(result)  # 输出: 4.0

需要注意的是，eval() 函数可以执行任意的表达式，包括调用函数和访问变量。这也意味着它可能会执行任意的代码，因此在使用 eval() 函数时应谨慎，确保只对可信任的字符串进行求值。不安全的输入可能导致代码注入和安全漏洞。

20. random模块中的函数

在 Python 中，random 模块是一个用于生成伪随机数的模块。它提供了各种函数来生成随机数、随机选择元素以及对序列进行洗牌等操作。以下是 random 模块中常用的函数解析：

random.random()

1. random(): 生成一个位于 [0, 1) 范围内的随机浮点数。

import random
num = random.random()
print(num)  # 输出：0.123456789 (随机值)

random.randrange()

2. randrange(start, stop[, step]): 生成一个指定范围内的随机整数。可指定起始值 start、结束值 stop 和步长 step（可选）。

import random
# 左闭右开，指定步长
print(random.randrange(1,10,2))  # 随机生成1,3,5,7,9中的一个整数

random.randint()

3. randint(a, b): 生成一个指定范围内的随机整数，包括起始值 a 和结束值 b。

import random
# 左闭右闭合
print(random.randint(1, 2))
# 输出1,2随机一个整数

random.choice()

4. choice(seq): 从给定的序列 seq 中随机选择一个元素并返回。

import random
fruits = ["apple", "banana", "cherry"]
print(random.choice(fruits))

random.sample()

5. sample(population, k): 从给定的总体 population 中随机选择 k 个独立的元素作为样本，并以列表形式返回。

import random
numbers = [1, 2, 3, 4, 5]
# 输出：随机选择的 3 个独立数字的列表 ps:不可能出现重复!
print(random.sample(numbers, 3))

21. del关键字

del 是 Python 中的一个关键字，用于删除对象或对象中的元素。它可以用于删除变量、列表中的元素、字典中的键值对等。

1. 删除变量：

x = 10
del x  # 删除变量 x

2. 删除列表中的元素：

lst = [1, 2, 3, 4, 5]
del lst[2]  # 删除索引为2的元素，结果为 [1, 2, 4, 5]

3. 删除字典中的键值对：

dct = {'a': 1, 'b': 2, 'c': 3}
del dct['b']  # 删除键为 'b' 的键值对，结果为 {'a': 1, 'c': 3}

4. 删除列表中的切片：

lst = [1, 2, 3, 4, 5]
del lst[1:3]  # 删除索引为1到2的元素，结果为 [1, 4, 5]

22. list函数

list() 是 Python 中的一个内置函数，用于将可迭代对象（iterable）转换为列表（list）对象。可迭代对象可以是字符串、元组、字典、集合等。

语法：

list(iterable)

参数：

iterable：要转换为列表的可迭代对象。

返回值：

返回一个包含可迭代对象中所有元素的列表。

示例：

str1 = "Hello, World!"
lst1 = list(str1)
print(lst1)  # 输出: ['H', 'e', 'l', 'l', 'o', ',', ' ', 'W', 'o', 'r', 'l', 'd', '!']

tpl1 = (1, 2, 3, 4, 5)
lst2 = list(tpl1)
print(lst2)  # 输出: [1, 2, 3, 4, 5]

dct1 = {'a': 1, 'b': 2, 'c': 3}
lst3 = list(dct1)
print(lst3)  # 输出: ['a', 'b', 'c']

23. zip函数

zip() 是 Python 中的一个内置函数，用于将多个可迭代对象（iterable）打包成一个元组的列表。它将每个可迭代对象中相同位置的元素组合在一起，返回一个迭代器。

语法：

zip(*iterables)

参数：

iterables：一个或多个可迭代对象，可以是列表、元组、字符串或其他可迭代对象。

返回值：

返回一个迭代器，其中每个元素都是由输入的可迭代对象中相同位置的元素组成的元组。

注意事项：

zip() 函数会以最短的可迭代对象的长度为准，如果可迭代对象长度不一致，则最终的结果列表会被截断为最短长度。

示例：

lst1 = [1, 2, 3]
lst2 = ['a', 'b', 'c']
lst3 = [10, 20, 30]

zipped = zip(lst1, lst2, lst3)
print(list(zipped))  # 输出: [(1, 'a', 10), (2, 'b', 20), (3, 'c', 30)]

在以上示例中，zip() 函数将 lst1、lst2 和 lst3 中相同位置的元素依次打包成了元组，并返回了一个迭代器。使用 list() 函数将迭代器转换为列表后，可以看到每个元组由相同位置的元素组成。

zip() 函数还可以与解压（unpacking）一起使用，将打包的元组解压为单独的可迭代对象：

zipped = [(1, 'a'), (2, 'b'), (3, 'c')]
# *zipped就相当于是说，把列表拆成3个参数传递到函数中。
# 相当于 zip((1, 'a'), (2, 'b'), (3, 'c'))
lst1, lst2 = zip(*zipped)
print(lst1)  # 输出: (1, 2, 3)
print(lst2)  # 输出: ('a', 'b', 'c')

24. enumerate函数

enumerate() 函数是 Python 中的内置函数，用于同时遍历索引和元素的可迭代对象。它返回一个可迭代对象，每个元素都是一个包含索引和对应元素的元组。

enumerate() 函数的语法如下：

enumerate(iterable, start=0)

参数解释：

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

下面是一些使用 enumerate() 函数的示例：

1. 遍历列表并输出索引和元素：

fruits = ['apple', 'banana', 'orange']
for index, fruit in enumerate(fruits):
    print(index, fruit)
'''
0 apple
1 banana
2 orange
'''

2. 使用指定的起始索引：

fruits = ['apple', 'banana', 'orange']
for index, fruit in enumerate(fruits, start=1):
    print(index, fruit)
    '''
    1 apple 
    2 banana
    3 orange
  	 '''

3. 将 enumerate() 的结果转换为列表：

fruits = ['apple', 'banana', 'orange']
enum_list = list(enumerate(fruits))
print(enum_list)
# [(0, 'apple'), (1, 'banana'), (2, 'orange')]

通过使用 enumerate() 函数，可以轻松地同时访问可迭代对象的索引和元素，方便进行迭代操作和索引处理。

25. .remove()函数

在 Python 中，remove() 函数用于从列表中移除指定的元素。它会找到第一个匹配的元素，并将其从列表中删除。

remove() 函数的语法如下：

list.remove(element)

其中，list 是要操作的列表，element 是要移除的元素。

下面是一些使用 remove() 函数的示例：

fruits = ['apple', 'banana', 'orange']
fruits.remove('banana')
print(fruits)  # 输出: ['apple', 'orange']

在上述示例中，remove(‘banana’) 会从列表 fruits 中移除第一个匹配的元素 ‘banana’。最终列表中只剩下 ‘apple’ 和 ‘orange’。

需要注意的是，如果要移除的元素不存在于列表中，会触发 ValueError 异常。因此，在调用 remove() 函数之前，最好先使用 in 运算符检查元素是否存在于列表中。

fruits = ['apple', 'banana', 'orange']
if 'banana' in fruits:
    fruits.remove('banana')
else:
    print('Element not found')

在上述示例中，先使用 in 运算符检查 ‘banana’ 是否存在于列表中，然后再调用 remove() 函数进行删除操作。如果元素存在，就会被移除；如果不存在，会输出 ‘Element not found’。

26. .index函数

在 Python 中，.index() 函数用于返回指定元素在列表中第一次出现的索引。
.index() 函数的语法如下：

list.index(element, start, end)

其中，list 是要操作的列表，element 是要查找的元素，start 是可选参数，表示查找的起始位置，默认为列表的开头，end 是可选参数，表示查找的结束位置，默认为列表的末尾。

下面是一些使用 .index() 函数的示例：

fruits = ['apple', 'banana', 'orange', 'banana']
index = fruits.index('banana')
print(index)  # 输出: 1

在上述示例中，.index(‘banana’) 会返回列表 fruits 中第一次出现 ‘banana’ 的索引，即 1。

如果要查找的元素不存在于列表中，会触发 ValueError 异常。因此，在调用 .index() 函数之前，最好先使用 in 运算符检查元素是否存在于列表中。

fruits = ['apple', 'banana', 'orange']
if 'banana' in fruits:
    index = fruits.index('banana')
    print(index)
else:
    print('Element not found')

在上述示例中，先使用 in 运算符检查 ‘banana’ 是否存在于列表中，然后再调用 .index() 函数进行查找操作。如果元素存在，就会返回它的索引；如果不存在，会输出 ‘Element not found’。

此外，还可以通过指定 start 和 end 参数来限制查找的范围。例如，要在列表的一部分中查找元素的索引：

fruits = ['apple', 'banana', 'orange', 'banana']
# 左闭右开
index = fruits.index('banana', 2, 4)
print(index)  # 输出: 3

在上述示例中，.index(‘banana’, 2, 4) 会从索引 2 开始，在索引 4 之前（不包括索引 4）的范围内查找 ‘banana’ 的索引，结果为 3。

27. .insert函数

x = [2,4,6,8]
x.insert(1, 3)
print(x)

28. 生成器表达式

生成器表达式是一种使用简洁语法创建生成器的方法。它类似于列表推导式，但使用圆括号而不是方括号。生成器表达式可以在需要的时候逐个生成值，而不会一次性生成整个序列，从而节省内存空间。

下面是一个简单的例子，说明生成器表达式的用法：

# 生成一个包含数字的生成器
generator = (x for x in range(1, 6))

# 逐个输出生成器的值
for num in generator:
    print(num)

# 输出结果:
# 1
# 2
# 3
# 4
# 5

在上述示例中，生成器表达式 (x for x in range(1, 6)) 生成了一个包含数字 1 到 5 的生成器。然后，通过迭代生成器，我们逐个输出生成器的值，即数字 1 到 5。

与列表推导式不同，生成器表达式不会立即生成一个完整的列表，而是在需要时逐个生成值。这在处理大量数据时特别有用，可以避免占用过多的内存空间。

29. set函数

在Python中，set() 是一个内置函数，用于创建一个集合对象。集合是一种无序、无重复元素的数据结构，可以用于快速地判断一个元素是否存在于集合中。

set() 函数可以接受一个可迭代对象作为参数，例如列表、元组、字符串等，然后将其中的元素去重并构建一个集合对象。

下面是一些使用 set() 函数的示例：

# 创建一个空集合
empty_set = set()
print(empty_set)  # 输出: set()

# 创建一个包含多个元素的集合
numbers = set([1, 2, 3, 4, 5])
print(numbers)  # 输出: {1, 2, 3, 4, 5}

# 创建集合时去除重复的元素
duplicate_set = set([1, 2, 2, 3, 3, 3])
print(duplicate_set)  # 输出: {1, 2, 3}

# 使用字符串创建集合
string_set = set("Hello")
print(string_set)  # 输出: {'H', 'e', 'l', 'o'}

# 使用集合推导式创建集合
squared_set = {x**2 for x in range(5)}
print(squared_set)  # 输出: {0, 1, 4, 9, 16}

# 将字典转换成集合
dict = {1:'a',2:'b'}
print(set(dict))
# {1, 2}

在上述示例中，我们通过 set() 函数创建了不同类型的集合。可以通过传递不同的可迭代对象来构建集合，同时可以使用集合推导式来创建更复杂的集合。注意，集合是无序的，因此输出的顺序可能与输入的顺序不同。另外，集合中不允许重复的元素，重复的元素将自动被去除。

30. .join函数

.join() 是字符串的一个方法，用于将可迭代对象中的字符串元素连接起来，形成一个新的字符串。它接受一个可迭代对象作为参数，并返回一个字符串。

语法如下：

new_string = separator.join(iterable)

其中，separator 是连接字符串之间的分隔符，可以是空字符串或任意字符串；iterable 是一个可迭代对象，如列表、元组、字符串等。

举个例子：

names = ['Alice', 'Bob', 'Charlie']
joined_string = ', '.join(names)
print(joined_string)

输出：

Alice, Bob, Charlie

在上面的例子中，我们有一个列表 names，其中包含三个字符串元素。使用 .join() 方法将列表中的字符串元素连接起来，使用逗号和空格作为分隔符，形成一个新的字符串 Alice, Bob, Charlie。

31. dict函数

dict() 是一个内置函数，用于创建一个字典对象。它可以从可迭代对象、关键字参数或其他字典创建新的字典。

语法如下：

new_dict = dict(iterable)
new_dict = dict(**kwargs)

其中，iterable 可以是一个可迭代对象，如列表、元组、集合等，包含键值对的子项。每个子项必须是一个包含两个元素的序列（例如，元组或列表），第一个元素为键，第二个元素为值。

举个例子：

student_scores = [('Alice', 85), ('Bob', 92), ('Charlie', 78)]
scores_dict = dict(student_scores)
print(scores_dict)  # {'Alice': 85, 'Bob': 92, 'Charlie': 78}

在上面的例子中，我们有一个包含学生姓名和对应分数的列表student_scores。我们使用 dict() 函数将这个列表转换为一个字典 scores_dict，其中学生姓名作为键，分数作为值。

除了从可迭代对象创建字典外，dict() 函数还可以接受关键字参数的形式创建字典，或者通过其他字典创建新的字典。下面是一些例子：

# 使用关键字参数创建字典
person = dict(name='Alice', age=25, city='New York')
print(person)  # {'name': 'Alice', 'age': 25, 'city': 'New York'}

# 通过其他字典创建新的字典
old_dict = {'a': 1, 'b': 2, 'c': 3}
new_dict = dict(old_dict)
print(new_dict)     # {'a': 1, 'b': 2, 'c': 3}

32. read、readeline、readlines

在 Python 中，read(), readline(), 和 readlines() 是用于从文件对象中读取数据的方法，它们之间有以下区别：

1. read(): 该方法用于一次性读取整个文件内容，并将内容作为字符串返回。如果不指定参数，则默认读取整个文件。如果指定参数 size，则会读取指定大小的数据。

示例：

# 打开文件
file = open("example.txt", "r")

# 读取整个文件内容
content = file.read()
print(content)

# 关闭文件
file.close()

2. readline(): 该方法用于逐行读取文件内容。每次调用 readline() 方法会读取文件中的一行，并返回该行内容作为字符串。连续调用 readline() 方法会依次读取文件中的每一行。

# 打开文件
file = open("example.txt", "r")

# 逐行读取文件内容
line1 = file.readline()
print(line1)

line2 = file.readline()
print(line2)

# 关闭文件
file.close()

3. readlines(): 该方法用于一次性读取整个文件内容，并将每一行作为一个元素存储在列表中返回。每一行内容都是字符串类型。

示例：

# 打开文件
file = open("example.txt", "r")

# 读取整个文件内容并以行为单位存储在列表中
lines = file.readlines()
print(lines)

# 关闭文件
file.close()