常用内置函数

目录

• 一、匿名函数
• 二、max/min函数
• 三、filter函数
• 四、map函数
• 五、sorted函数
• 六、其它内置函数

一、匿名函数

匿名函数即没有名字的函数，使用一次就被回收，加括号就可以运行。

语法：

lambda 参数：返回值

res = lambda x,y:x+y
print(res(1,2))

二、max/min函数

res = max([1, 2, 3, 4, 5])
print(res)

res = max(1, 2, 3, 4, 5, 6, )
print(res)

salary_dict = {
    'nick': 3000,
    'jason': 100000,
    'tank': 5000,
    'sean': 2000,
    'z': 1000
}

def func(name):  # nick/jason/tank/sean/z
    return salary_dict[name]  # 3000/100000/5000/2000/1000


res = max(salary_dict, key=func)  # 默认key的首字母
res2 = max(salary_dict, key=lambda name: salary_dict[name])  # 默认key的首字母

print(res)

#-------------------------------------------------------#


res = min(salary_dict, key=lambda name: salary_dict[name])
print(res)

key=func默认做的事情：

1. 循环遍历salary_dict,会取到所有的key值
2. 然后把所有的key值依次丢入func中,返回薪资
3. 通过返回的薪资排序,得到最大值

三、filter函数

filter意为筛选

def function(item):  # 1/2/3/4
    if item < 5:
        return True
    else:
        return False


# res = filter(function, [1, 2, 3, 4])
res = filter(lambda item: item > 2, [1, 2, 3, 4])
print(res)  # 迭代器
print(list(res))
 # filter({lambda 元素(可迭代对象内元素): 元素需要满足的条件} ，[可迭代对象])
 # filter({有名函数} ，[可迭代对象])  这个函数需要返回true 或者false
 #                                 是用来判断的函数

四、map函数

映射函数，可以用来进行数学计算

def function1(item):
    return item + 2


res = map(function1, [1, 2, 3])
print(res)
print(list(res))
 # map({lambda 元素(可迭代对象内元素): 元素需要满足的条件} ，[可迭代对象])
 # map({有名函数} ，[可迭代对象])  这个函数需要返回一个具体的值，用来对参数做运算
 # 是用来变换的函数

五、sorted函数

def function2(item):
    return salary_dict[item]


salary_dict = {
    'nick': 3000,
    'jason': 100000,
    'tank': 5000,
    'sean': 2000,
    'z': 1000
}

# res = sorted([2,3,4,1,0,5],key=function2,reverse=True)
res = sorted(salary_dict, key=function2, reverse=True)
print(list(res))
# 这里的function只能用于去除字典里的value

六、其它内置函数

python解释器内置方法

# bytes
res = bytes('中国', encoding='utf8')
print(res)
# chr/ord
print(chr(97))
print(ord('a'))
# divmod
print(divmod(10, 4))  # 取整/取余
# enumerate(********)
lt = [1, 2, 3]
for i in range(len(lt)):
    print(i, lt[i])

for ind, val in enumerate(lt):
    print(ind, val)

# eval(***) --> 把字符串的引号去掉,留下来的是什么就是什么

s = '"abc"'
print(type(eval(s)), eval(s))
# hash,可变不可哈希
print(hash(123123))

# 了解

# abs
print(abs(-1))
# all# 可迭代对象内的元素全部为True则为True
print(all([1, 2, 3, 3]))
# any
print(any([0, 0, ]))
# bin/oct/hex
print(bin(123))
print(oct(123))
print(hex(123))
# dir: 列出模块的所有方法
# import time
#
# print(dir(time))
# frozenset: 不可变化的集合,类似于元组
s = frozenset({1, 2, 3})
print(s)


# gloabals/locals
# print(globals())  # 列出所有全局变量
# print('locals():', locals())


def func():
    s = 's1'
    print(globals())  # 列出所有全局变量
    print('locals():', locals())  # 列出当前位置所有变量


func()
# pow
print(pow(2, 2))
# round
print(round(10.333))
# slice
s = slice(1, 5, 2)  # 1start,5stop,2step
lt = [1, 2, 3, 4, 5, 6, 7]
print(lt[s])
print(lt[1:5:2])
# # sum
print(sum([1, 2, 3, 4, 5]))
# __import__  # 通过字符串导入模块
# import 'time'


time = __import__('time')
print(time.time())