匿名函数,内置函数

一.匿名函数

1.匿名函数: 一句话, 比较简单的函数(变量名 = lambda 形参 : 返回结果 )

1. 此函数不是没有名字，他是有名字的，他的名字就是你给其设置的变量，比如func.

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

3. lambda 后面直接加形参，形参加多少都可以，只要用逗号隔开就行。

4. 返回值在冒号之后设置，返回值和正常的函数一样,可以是任意数据类型。

5. 匿名函数不管多复杂.只能写一行.且逻辑结束后直接返回数据

6. 匿名函数的三个规则:

   1. 一般有一行表达式, 必须要有返回值

   2. 不能有return

   3. 可以没有参数, 也可以有个或多个参数

def func(a, b)
    return a+b
# 构建匿名函数
func1 = lambda a, b: a+b
print(func1(1,2))
​
lambda x: x**3  # 一个参数
lamdba x,y: x+y  # 多个个参数
lamdba x,y=3: x+y  # 允许参数有默认值

• 接收一个可切片的数据，返回索引为0与2的对应的元素（元组形式）。

• ret = lambda x: (x[0], x[2])
  print(ret([11, 22, 3, 45]))

• 写匿名函数：接收两个int参数，将较大的数据返回。

• lambda a,b: a if a > b else b

二.内置函数

# int 返回的是整数部分
# print(int(3.6))
​
# float 浮点数
# print(type(3.6))
​
# complex
# print(complex(4, 5))
​
# bin 将十进制转化成二进制并返回
# print(bin(19))
# oct 将十进制转化成八进制字符串并返回
# print(oct(12))
# hex 将十进制转化成十六进制字符串并返回
# print(hex(13))
​
# divmod  返回除数, 以及余数, 返回的是一个元组
# print(divmod(10,3))
# print(divmod(4, 2))
# round: 保留浮点数的小数位数
# print(round(3.141592653, 3))
​
# pow 求x**y次幂(三个参数是为x**y的结果对z取余)
# print(pow(2, 3))
# print(pow(2, 3, 2))
​
# bytes  转化为字节类型
# s1 = '悟空'
# b = s1.encode('utf-8')
# print(b)
# a = bytes(s1, encoding='utf-8')
# print(a)
​
# ord : 输入字符找该字符编码的位置
# 会先在ascii编码中找, 找不到去Unicode中找
# print(ord('a'))
# print(ord('中'))
​
# chr: 输入位置数字找出其对应的字符
# print(chr(65))
# print(chr(20013))  # Unicode
​
# repr : 返回一个对象的string形式(原形毕露)
# s1 = '八戒'
# # print(repr(s1))
# msg = f'我叫{repr(s1)}'
# print(msg)
​
# all: 可迭代对象中, 全都是True才是true  只针对可迭代对象的第一层
# l1 = [11, 22, 3, 4, [False, 2, ''],]  # 这种就返回的是True
# l2 = [11, 22, 3, 4, [2,6], '']
# print(all(l1))
# print(all(l2))
# any: 可迭代对象中, 有一个是True就是True
# l1 = [11, 22, 3, 4, [False, 2, ''],]
# print(any(l1))
​
# print(1, 2, end='')
# print(2)
​
# list
# 列表的创建
# l1 = [1, 2,3]
# l2 = list()  # l2是一个空列表
# l2 = list('adfasdfas')
# print(l2)
​
# dict 创建字典的几种方式
# 直接创建
# 元组的解构
# dic = dict([(1, 'one'), (2, 'two')])
# print(dic)
​
# dic = dict(one=1, two=2)
# print(dic)
​
# fromkeys
# dic = dict.fromkeys([1,2,3], '太白')
# print(dic)
# update
​
# 字典的推导式
# dic = {k:v for k, v in ((1, 'one'), (2, 'two'))}
# print(dic)
​
# abs 绝对值
# print(abs(-8))
​
# sum
# l1 = [i for i in range(10)]
# print(sum(l1, 100))
​
​
# reversed 返回的是一个反转的迭代器, 操作的是一个新的列表
# l1 = [i for i in range(10)]
# # l1.reverse()  # 列表的方法, 它是操作的原来的列表
# # print(l1)
# obj = reversed(l1)  # 这里返回的是一个迭代器
# print(l1)
# print(list(obj))
​
# zip 拉链方法
# l1 = [1, 2, 3, 4, 5]
# tu1 = ('八戒', 'b哥', '悟空')
# s1 = 'abcd'
​
# obj = zip(l1, tu1, s1)
# print(list(obj))
# [(1, '八戒', 'a'), (2, 'b哥', 'b'), (3, '悟空', 'c')]
​
​
# 最重要的内置方法
# min max
# l1 = [33, 2, 3, 54, 7, -1, -9]
# print(min(l1))
# l2 = []
# func = lambda x: abs(x)
# for i in l1:
#     l2.append(func(i))
# print(min(l2))
​
# 求列表中绝对值最小的那个值
# l1 = [33, 2, 3, 54, 7, -1, -9]
# def func(args):
#     return abs(args)
#
#
# print(min(l1, key=func))
# 凡是可以加key的, 它会自动的将可迭代对象中的每个元素按照顺序传入key对应的函数中
​
# dic = {'a': 3, 'b': 2, 'c': 1}
# 求出值最小的键
# def func(args):
#     return dic[args]
# print(min(dic, key=lambda args:dic[args]))
​
# l2 = [('八戒',18), ('悟空', 73), ('唐僧', 35), ('沙僧', 41)]
# print(min(l2, key=lambda x:x[1]))
​
# sorted 加key
# l1 = [22, 33, 1, 2, 8, 7,6,5]
# l2 = sorted(l1)
# print(l1)
# print(l2)
​
# l2 = [('八戒', 76), ('悟空', 70), ('唐僧', 94), ('沙僧', 98), ('b哥',96)]
# print(sorted(l2, key=lambda x:x[-1]))  # 按照数字排序, 默认从低到高
# print(sorted(l2, key=lambda x:x[1], reverse=True))  # 反转
​
# l1 = [2, 3, 4, 1, 6, 7, 8]
# print([i for i in l1 if i > 3])  # 返回的是列表
# ret = filter(lambda x: x > 3, l1)  # 返回的是迭代器
# print(list(ret))
​
# reduce
from functools import reduce
​
​
def func(x, y):
    '''
        第一次：x  y  : 11  2     x + y =     记录： 13
        第二次：x = 13   y  = 3    x +  y =   记录： 16
        第三次  x = 16   y = 4 .......
        '''
    return x + y
​
​
l = reduce(func, [11, 2, 3, 4])
print(l)
​