内置函数
匿名函数
匿名函数的作用
为了解决一些功能简单的需求而设计的一句话函数，不需要命名
'''
一般的函数
'''
# 计算n的平方
def func(num):
return num * num
f = func(2)
print(f)
结果
4
匿名函数
lambda表示的就是匿名函数，不需要def声明，直接创建一个函数
'''
匿名函数
'''
f = lambda x: x * x
print(f(2))
4
语法
函数名 = lambda 参数： 返回值
注意
注意的要点
- 函数的参数可以有多个，多个参数之间用逗号隔开
- 匿名函数不管逻辑是多么的复杂，只能写一行，并且在逻辑结束之后直接返回数据
- 返回值和普通的函数一样，可以是任意的数据类型
匿名函数不是没有名字！！！
匿名函数不是说函数没有名字，前面的变量的名字就是一个函数的名字，之所以叫做匿名的函数是因为通过__name__查看的时候是没有名字的，统一的叫做lambda，在调用的时候和普通的函数没有区别。
sorted()排序函数
排序函数，对原数据没有进行修改，返回的数据结构只能是list
st = 'test'
new = sorted(st)
print(st) # 没有对原数据进行修改
print(new, type(new)) # sort后的结果,只能是list
test
['e', 's', 't', 't'] <class 'list'>
语法
sorted(Iterable, key=None, reverse=False)
参数
Iterable可迭代的对象key: 排序规则(排序函数), 在sorted内部会将可迭代对象中的每一个元素传递给这个函数，作为该函数的参数. 根据函数运算的结果进行排序reverse: 是否倒序，True:倒序，Fales：正序
lst = [1, 7, 2, 4, 3]
sorted_lst = sorted(lst)
print(lst) # 原来的列表是不会改变的
print(sorted_lst) # 返回的新列表是经过排序的
结果
[1, 7, 2, 4, 3]
[1, 2, 3, 4, 7]
list自带着排序的方法，直接操作原数据
lst = [1, 7, 2, 4, 3]
lst.sort() # 列表.sort → 相当于一个函数，在sort结束后 返回的是一个None 但是原列表已经变化
--------------------------------------------------------------------------------------------------
def sort(self, key=None, reverse=False): # real signature unknown; restored from __doc__
""" L.sort(key=None, reverse=False) -> None -- stable sort *IN PLACE* """
pass
--------------------------------------------------------------------------------------------------
print(lst)
lst.sort(reverse=True) # sort函数的参数，是否倒序，默认的是False
print(lst)
lst.reverse() # 直接倒序 和sort一样
--------------------------------------------------------------------------------------------------
def reverse(self): # real signature unknown; restored from __doc__
""" L.reverse() -- reverse *IN PLACE* """
pass
--------------------------------------------------------------------------------------------------
print(lst)
结果
[1, 2, 3, 4, 7]
[7, 4, 3, 2, 1]
[1, 2, 3, 4, 7]
如果可迭代的对象是字典，则返回的是排序过后的key
dic = {2: 'c', 9: 'r', 4: 'a'}
sorted_dic = sorted(dic)
print(dic)
print(sorted_dic)
结果
{2: 'c', 9: 'r', 4: 'a'}
[2, 4, 9] # 返回的是经过排序的key的列表
配合函数的使用
根据字符创的长度排序
def func(arg):
return len(arg)
lst = ['哈哈', '啊实打实多', '1', '打算打']
print(sorted(lst, key=func))
结果
['1', '哈哈', '打算打', '啊实打实多']
配合lambad的使用
lst = ['哈哈', '啊实打实多', '1', '打算打']
print(sorted(lst, key=lambda x: len(x), reverse=True)) # 倒序
结果
['啊实打实多', '打算打', '哈哈', '1']
字典使用lambda
排序的元素是可迭代对象，最好返回排序好的结果也是的迭代的元素
lst = [
{"id":1, "name":'alex', "age":18},
{"id":2, "name":'wusir', "age":16},
{"id":3, "name":'taibai', "age":17},
]
print(sorted(lst, key=lambda x: x.get('age')))
结果
[{'id': 2, 'name': 'wusir', 'age': 16}, {'id': 3, 'name': 'taibai', 'age': 17}, {'id': 1, 'name': 'alex', 'age': 18}]
filter()筛选函数
语法
filter(function. Iterable)
"""
filter(function or None, iterable) --> filter object
Return an iterator yielding those items of iterable for which function(item)
is true. If function is None, return the items that are true.
"""
参数
function：用来筛选的函数. 在filter中会自动的把iterable中的元素传递给function. 然后
根据function返回的True或者False来判断是否保留留此项数据Iterable：可迭代对象
返回的是True保留， False就略过，最后筛选的是True保留的结果
引入
def func(args):
'''
返回传进来的参数除以2是否等于0
:param args:
:return: True or False
'''
return args % 2 == 0
print(func(7))
print(func(8))
结果
False
True
例子
lst = [1, 2, 3, 4, 5, 6]
filter_lst = filter(lambda x: x % 2 == 0, lst)
print(filter_lst) # 返回的是迭代器
print(list(filter_lst))
结果
<filter object at 0x00000000028E73C8>
[2, 4, 6]
lst = [
{"id":1, "name":'alex', "age":18},
{"id":2, "name":'wusir', "age":16},
{"id":3, "name":'taibai', "age":17},
]
filter_lst = filter(lambda x: x.get('age') > 16, lst) # 大于16的留下
print(filter_lst)
print(list(filter_lst)) # list内置函数,只能返回list
s = list()
print(s, type(s))
结果
<filter object at 0x0000000002974630>
[{'id': 1, 'name': 'alex', 'age': 18}, {'id': 3, 'name': 'taibai', 'age': 17}]
[] <class 'list'>
map()函数
映射函数
语法
map(function, iterable)
对可迭代对象中的每一个元素进行映射，分别进行function
引入
def func(args):
return args * args # **2 or args ** args 幂 ** 3 三次方 ** 0.5 开方
a = func(3)
print(a)
结果
9
计算列表中每个数的平方
一般的写法
def func(args):
return args * args # **2 or args ** args 幂 ** 3 三次方 ** 0.5 开方
mp = map(func, [1, 2, 3, 9])
print(mp)
print(list(mp))
结果
<map object at 0x00000000028F73C8>
[1, 4, 9, 81]
lambda的写法
mp = map(lambda x: x ** 2, [1, 2, 4, 9])
print(mp)
print(list(mp))
结果
<map object at 0x0000000001E773C8>
[1, 4, 16, 81]
计算两个列表相同位置的数据和
lis1 = [1, 2, 3, 5, 9]
lis2 = [10, 18, 67, 64, 90]
print(list(map(lambda x, y: x + y, lis1, lis2)))
结果
[11, 20, 70, 69, 99]
浙公网安备 33010602011771号