python中的函数#5

一. 匿名函数

匿名函数：匿名函数是一种没有名称的函数。它通常用于需要一个临时函数的场合，例如作为另一个函数的参数或返回值匿名函数可以像普通函数一样使用，但是它们没有名称，因此只能通过变量或参数传递它们。

匿名函数的语法格式：

lambda 形参：返回值

# lambda 形参：返回值
# 
# lambda x：x+1 其实就等于
# def index():
#     返回值
# index()
res = lambda x, y: x+y
print(res(1, 3))##4

二.常见的匿名函数 

一般用于配合匿名函数使用，如：map , zip ,max, min, filter等

1. map

map：map的内置就是for循环：

##循环列表中的所有数
l = [1, 2, 3, 4, 5]
def index(x):
    return x+1
res = map(lambda x: x+1, l)
print(list(res))

#将列表里的所有数全部为**2
l1 = [1, 2, 3, 4, 5]
def index(x):
    return x**2
res = map(lambda x: x**2, l1)
print(list(res))#[1, 4, 9, 16, 25]

2. zip

zip(拉链) zip 是 Python 的内置函数之一，可以将多个可迭代对象组合成一个元组序列，返回一个迭代器对象。它的语法如下：

l1 = ['name', 'age', 'gender']
l2 = ['kiki', 19, 'male']

res = zip(l1, l2)
print(list(res))#[('name', 'kiki'), ('age', 19), ('gender', 'male')]

另外，zip 函数也支持不同长度的可迭代对象作为参数，此时会以最短的序列为准进行组合匹配。例如

a = [1, 2, 3]
b = ['a', 'b']
result = zip(a, b)

for i in result:
    print(i)

3. min和max

min和max 在字典中比较时比较的是key值，

min()和max()是python中的内置函数，用于在给定的对象（可迭代对象）中找到最小值和最大值。

例如，对于一个列表，min()返回列表中最小的元素，max()返回最大的元素：

numbers = [4, 2, 8, 1, 5, 9]
minimum = min(numbers)  # 返回1
maximum = max(numbers)  # 返回9

同时对于一个字符串，min()和max()返回的是按照字符编码顺序最小和最大的字符

text = "hello world"
minimum = min(text)  # 返回空格字符（ASCII码32）
maximum = max(text)  # 返回字符"o"（ASCII码111）

注：不同的对象类型可能有不同的比较方式，因此，min()和max()可能会产生不同的结果。

4.filter

filter是Python内置的高阶函数之一，它的作用是过滤列表中的元素，返回一个由符合过滤条件的元素组成的新列表。filter()函数的语法如下：

filter(function, iterable)

使用：

res = [11, 22, 33, 44, 55, 66]
def index(x):
    return x > 30
res1 = filter(lambda x: x > 30, res)
print(list(res1))

三. 可迭代对象

迭代：更新换代，每次更新都是基础上一次结果。

可迭代对象：内置有__iter__方法的都可以称为是可迭代对象，内置：可以直接使用的可迭代对象有:str , list , dict, set, tuple 都是可迭代对象。__iter__开头的方法都有与之对应的简写。        

s = 'hello'
print(s.__iter__())

print(iter(s))##简写

print(s.__len__())##查看位数在



def index(s):
    return s.__iter__()
res = index(s)
print(res)

1.迭代器对象

迭代器：内置有__iter__还内置__next__方法，

是一种对象，它可以按照一定的顺序遍历容器中的元素。迭代器需要实现两个方法：__iter__()和__next__()。

__iter__()方法返回的是迭代器对象本身，__next__()方法返回容器中的下一个元素。如果已经到达容器末尾，__next__()方法将抛出StopIteration异常

有迭代器对象调用__iter__（）方法转为迭代器。

s = 'hello'

res = s.__iter__()
print(res.__next__())#h

print(res.__next__())#e

print(res.__next__())#l

print(res.__next__())#l

print(res.__next__())##p

# next就是迭代取值，不会依赖索引取值，迭代取值之后，一旦被取完就会报错

简写

迭代超过就会报错

易错题：

可迭代对象调用多次__iter__方法仍然是迭代器对象

l = [1, 2, 3, 4]
print(l.__iter__().__next__()) # 1
print(l.__iter__().__next__()) # 1
print(l.__iter__().__next__()) # 1
print(l.__iter__().__next__()) # 1

res = l.__iter__()
print(res.__next__())  # 1
print(res.__next__())  # 2
print(res.__next__())  # 3
print(res.__next__())  # 4

2. for循环的内部原理

使列表中所有的元素值循环打印出来,不能使用for循环:

l1 = [1, 2, 3, 4, 5, 66]###不使用for循环，循环打印出列表的每一个元素值。
count = 0
while True:
    print(l1[count])
    count += 1
res = l1.__iter__()
while True:
    print(res.__next__())

但使用for循环为什么不会报错?

for循环内部的原理：
        1. 首先把关键字in后面的可迭代对象转为迭代器对象
        2. while循环取值__next__迭代取值，当next取值完毕的时候会报错
        3. 当内部报错的时候，for循环进行了异常捕捉.

四. 异常捕捉

什么是异常：异常就是错误发生的信号，如果不对该信号进行处理，那么异常发生之后的位置后面代码将无法运行。

1. 异常信息

1.Traceback ：追踪信息，当出现错误信息时，直接找到最后一行，点击就会跳转到错误的地址。

2 . xxxError  keyError.....指的是具体的发生的详细错误，一般从这就可以发现错误。

2.异常的分类

1.语法错误:是绝对不允许的，只要是语法错误代码是绝对运行不了的。通过代码提示就可以发现

2. 逻辑错误;在编码过程中是可以发生的，但我们也要避免这种情况发生。

3.如何捕获异常：在Python中，异常是指程序运行时发生的错误或意外情况，例如除以零、名称错误等。为了处理这些异常，Python提供了一种异常处理机制，即try-except语句

try:
    # 代码块
except ExceptionType:
    # 异常处理代码块

关键字：try

try:
    l = [1, 2, 3]
    print(l[4]) # IndexError
    # d = {'a':1}
    # print(d['b'])
    # 1/0
except NameError as e:
    print(e)
except KeyError as e:
    print(e)
except IndexError as e:
    print(e) # list index out of range
except ZeroDivisionError as e:
    print(e)

except

try:
    num1 = int(input("请输入被除数："))
    num2 = int(input("请输入除数："))
    res = num1 / num2
    print("结果为：", res)
except ZeroDivisionError:
    print("除数不能为0")

注意：只能当你的被监测代码可能会出现，但是，又不想让它报错，这个时候使用异常捕捉是最合适的
异常捕捉的代码尽量少的写

l = [1,2,3,4,5,6,7]
res= l.__iter__()
while True:
    try:
        print(res.__next__())
    except Exception:
        break