Pyhton中的一些常用内置函数和匿名函数lambda

"""
匿名函数（俗称一句话函数）
"""


# 我们先定义一个函数，只有一句话
def func(args):
    return args + 1


# 以上这个函数就等于下面这个 -- > (函数名 = lambda 参数:返回值)
func2 = lambda args: args + 1
print(func2(2))
"""
    1）此函数不是没有名字，他是有名字的，他的名字就是你给其设置的变量，比如func.

    2）lambda 是定义匿名函数的关键字，相当于函数的def.

    3）lambda 后面直接加形参，形参加多少都可以，只要用逗号隔开就行。
    
    4）返回值在冒号之后设置，返回值和正常的函数一样,可以是任意数据类型。

    5）匿名函数不管多复杂.只能写一行.且逻辑结束后直接返回数据
"""
"""
根据以上的知识点做一些题目巩固
"""
# 写匿名函数：接收一个可切片的数据，返回索引为0与2的对应的元素（元组形式）。
func3 = lambda trup: (trup[0], trup[2])
print(func3([1, 2, 3, 4, 5, 6]))  # (1, 3)

# 写匿名函数：接收两个int参数，将较大的数据返回。
func4 = lambda a, b: a if a > b else b
print(func4(3, 4))  # 4

"""
讲解一些python中的较为重点的内置函数
abs() enumerate() filter() map() max() min() open() 
range() print() len() list() dict() str() reversed() 
set() sorted() sum() tuple() type() zip() dir()
"""
# abs() 是返回一个绝对值
a = -1
print(abs(a))  # 1

# enumerate()函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。
"""
enumerate(sequence, [start=0]) 
    sequence -- 一个序列、迭代器或其他支持迭代对象。
    start -- 下标起始位置。
"""
l1 = ['cyx', 'csdn', 'yxinmiracle']
print(list(enumerate(l1)))  # [(0, 'cyx'), (1, 'csdn'), (2, 'yxinmiracle')]
print(list(enumerate(l1, start=1)))  # [(1, 'cyx'), (2, 'csdn'), (3, 'yxinmiracle')]

seq = ['one', 'two', 'three']
for i, element in enumerate(seq):
    print(i, element)  # 0 one
    # 1 two
    # 2 three

# list() 将一个可迭代对象转换成列表 ***记住一定是可迭代对象，不能随便乱放
l1 = list('abcd')
print(l1)  # ['a', 'b', 'c', 'd']

# tuple() 将一个可迭代对象转换成元组 ***记住一定是可迭代对象，不能随便乱放
tu1 = tuple('abcd')
print(tu1)  # ('a', 'b', 'c', 'd')

# sum() 求和
print(sum([1, 2, 3]))
print(sum((1, 2, 3), 100))  # 以100位起始值

# min() 求最小值
print(min([1, 2, 3]))  # 返回此序列最小值

ret = min([1, 2, -5], key=abs)  # 按照绝对值的大小，返回此序列最小值
print(ret)
# 加key是可以加函数名，min自动会获取传入函数中的参数的每个元素，然后通过你设定的返回值比较大小，返回最小的传入的那个参数。
print(min(1, 2, -5, 6, -3, key=lambda x: abs(x)))  # 可以设置很多参数比较大小

# 我想返回字典中的value最小值得key，我该怎么做
dic = {'a': 3, 'b': 2, 'c': 1}
# 这个key函数的返回值就是min函数的比较大小的值，他先找出这个key函数的返回值的最小值，然后min函数返回对应迭代的值
print(min(dic, key=lambda x: dic[x]))  # c

# 与上面的例子差不多相同
l2 = [('cyx', 18), ('al', 73), ('wu', 35), ('地包天', 41)]
print(min(l2, key=lambda a: a[1])[1])

# reversed() 将一个序列翻转, 返回翻转序列的迭代器
l = reversed('你好')  # l 获取到的是一个生成器
print(list(l))
ret = reversed([1, 4, 3, 7, 9])
print(list(ret))  # [9, 7, 3, 4, 1]

"""
语法:sorted(iterable,key=None,reverse=False)

iterable : 可迭代对象

key: 排序规则(排序函数),在sorted内部会将可迭代对象中的每一个元素传递给这个函数的参数.根据函数运算的结果进行排序

reverse :是否是倒叙,True 倒叙 False 正序
"""
lst = [1, 3, 2, 5, 4]
lst2 = sorted(lst)
print(lst)  # 原列表不会改变
print(lst2)  # 返回的新列表是经过排序的

lst3 = sorted(lst, reverse=True)
print(lst3)  # 倒叙

"""
映射函数
map()
语法: map(function,iterable) 可以对可迭代对象中的每一个元素进映射,分别取执行function

计算列表中每个元素的平方,返回新列表
"""
lst = [1, 2, 3, 4, 5]


def func(s):
    return s * s


mp = map(func, lst)
print(mp)  # <map object at 0x00000193CB9C93D0>
print(list(mp))  # [1, 4, 9, 16, 25]

# filter筛选过滤
"""
语法: filter(function,iterable)

function: 用来筛选的函数,在filter中会自动的把iterable中的元素传递给function,然后根据function返回的True或者False来判断是否保留此项数据

iterable:可迭代对象
"""

lst = [{'id': 1, 'name': 'alex', 'age': 18},
       {'id': 1, 'name': 'wusir', 'age': 17},
       {'id': 1, 'name': 'taibai', 'age': 16}, ]

ls = filter(lambda e: e['age'] > 16, lst)

print(list(ls))  # [{'id': 1, 'name': 'alex', 'age': 18}, {'id': 1, 'name': 'wusir', 'age': 17}]

# zip()拉链方法
l1 = [1, 2, 3, 4, 5]
l2 = [9, 8, 7, 6, 5]
for i,j in zip(l1,l2):
    print(i,j)
"""
输出
1 9
2 8
3 7
4 6
5 5
"""