Python刷题系列(3)_lambda函数

Python Lambda

1、创建一个 lambda 函数

编写一个 Python 程序来创建一个 lambda 函数，该函数将 15 作为参数传入的给定数字相加，还创建一个 lambda 函数，将参数 x 与参数 y 相乘并打印结果。

r = lambda a : a + 15
print(r(10))
r = lambda x, y : x * y
print(r(12, 4))

'''
25
48
'''

2、接受一个参数的函数，且该参数乘以给定数字

编写一个Python程序来创建一个接受一个参数的函数，该参数将乘以未知的给定数字。

def func_compute(n):
 return lambda x : x * n
result = func_compute(2)
print("Double the number of 15 ：", result(15))
result = func_compute(3)
print("Triple the number of 15 ：", result(15))
result = func_compute(4)
print("Quadruple the number of 15 ：", result(15))
result = func_compute(5)
print("Quintuple the number 15 ：", result(15))

'''
Double the number of 15 ： 30
Triple the number of 15 ： 45
Quadruple the number of 15 ： 60
Quintuple the number 15 ： 75
'''

3、使用 Lambda 对元组列表进行排序

编写一个 Python 程序，使用 Lambda 对元组列表进行排序。
元组的原始列表：
[（‘English’， 88）， （‘Science’， 90）， （‘Maths’， 97）， （‘Social sciences’， 82）]
排序元组列表：
[（‘Social Sciences’， 82）， （‘English’， 88）， （‘Science’， 90）， （‘Maths’， 97）]

方法一：使用sort函数

subject_marks = [('English', 88), ('Science', 90), ('Maths', 97), ('Social sciences', 82)]
print("Original list of tuples:")
print(subject_marks)
subject_marks.sort(key = lambda x: x[1])
print("\nSorting the List of Tuples:")
print(subject_marks)

'''
Original list of tuples:
[('English', 88), ('Science', 90), ('Maths', 97), ('Social sciences', 82)]

Sorting the List of Tuples:
[('Social sciences', 82), ('English', 88), ('Science', 90), ('Maths', 97)]
'''

这里使用sort函数中的参数key：
关于参数key ：为函数，指定取待排序元素的哪一项进行排序，函数用上面的例子来说明，代码如下：

students  =  [( 'john' ,  'A' ,  15 ), ( 'jane' ,  'B' ,  12 ), ( 'dave' ,  'B' ,  10 )]
sorted (students, key = lambda  student : student[ 2 ])

key指定的lambda函数功能是去元素student的第三个域（即：student[2]），因此sorted排序时，会以students所有元素的第三个域来进行排序。

方法二：使用sorted函数

subject_marks = [('English', 88), ('Science', 90), ('Maths', 97), ('Social sciences', 82)]
print("Original list of tuples:")
print(subject_marks)
a=sorted(subject_marks,key = lambda x: x[1])
print("\nSorting the List of Tuples:")
print(a)


'''
Original list of tuples:
[('English', 88), ('Science', 90), ('Maths', 97), ('Social sciences', 82)]

Sorting the List of Tuples:
[('Social sciences', 82), ('English', 88), ('Science', 90), ('Maths', 97)]
'''

4、使用 Lambda 对字典列表进行排序

编写一个 Python 程序来使用 Lambda 对字典列表进行排序。

models = [{'make':'Nokia', 'model':216, 'color':'Black'}, 
          {'make':'Mi Max', 'model':2, 'color':'Gold'}, 
          {'make':'Samsung', 'model': 7, 'color':'Blue'}]
print("Original list of dictionaries :")
print(models)
sorted_models = sorted(models, key = lambda x: x['model'])
print("\nSorting the List of dictionaries :")
print(sorted_models)

'''
Original list of dictionaries :
[{'make': 'Nokia', 'model': 216, 'color': 'Black'}, {'make': 'Mi Max', 'model': 2, 'color': 'Gold'}, {'make': 'Samsung', 'model': 7, 'color': 'Blue'}]

Sorting the List of dictionaries :
[{'make': 'Mi Max', 'model': 2, 'color': 'Gold'}, {'make': 'Samsung', 'model': 7, 'color': 'Blue'}, {'make': 'Nokia', 'model': 216, 'color': 'Black'}]
'''

对于字典的排序，就不能使用对元组的排序sort了，而是需要使用sorted函数。

sorted() 函数对所有可迭代的对象进行排序操作：

sorted(iterable, cmp=None, key=None, reverse=False)

sort 与 sorted 区别：
1、sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。
2、list 的 sort 方法返回的是对已经存在的列表进行操作，无返回值，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

• 【iterable】 可迭代对象。

• 【cmp】 比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0。（一般省略）

• 【key】主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
  常用的用来作为参数key的函数有 lambda函数和operator.itemgetter()
  尤其是列表元素为多维数据时，需要key来选取按哪一位数据来进行排序

• 【reverse】 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。

5、使用 Lambda 过滤整数列表

编写一个 Python 程序来使用 Lambda 过滤整数列表。

nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print("Original list of integers:")
print(nums)
print("\n偶数:")
even_nums = list(filter(lambda x: x%2 == 0, nums))
print(even_nums)
print("\n奇数:")
odd_nums = list(filter(lambda x: x%2 != 0, nums))
print(odd_nums)

'''
Original list of integers:
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

偶数:
[2, 4, 6, 8, 10]

奇数:
[1, 3, 5, 7, 9]
'''

如果不是匿名函数的写法：

def is_odd(n):
    return n%2 == 1
lst1 = list(filter(is_odd,[1,2,3,4,5,6,7,8,9,10]))
print(lst1)

'''
[1, 3, 5, 7, 9]
'''

【1】filter

filter()函数用于过滤序列，过滤掉不符合条件的元素，返回符合条件的元素组成新列表。

• filter()函数是python内置的另一个有用的高阶函数

• filter()函数接收一个函数f和一个list

• 这个函数f的作用是对每个元素进行判断,返回True或False

• filter()根据判断结果自动过滤掉不符合条件的元素

• 返回由符合条件元素组成的新list

• 3.7.3版filter需要嵌套在list里面

filter(function,iterable) 
# 其中function为函数，iterable为序列

6、使用 Lambda 查找是否以给定字符开头

编写一个 Python 程序，以使用 Lambda 查找给定字符串是否以给定字符开头。

starts_with = lambda x: True if x.startswith('P') else False
print(starts_with('Python'))
starts_with = lambda x: True if x.startswith('P') else False
print(starts_with('Java'))

'''
True
False
'''

关于startswith函数，返回的是布尔值：

print('Java'.startswith('P'))

'''
False
'''

7、使用 Lambda 提取年、月、日期和时间

编写一个 Python 程序，使用 Lambda 提取年份、月份、日期和时间。

import datetime
now = datetime.datetime.now()
print(now)
year = lambda x: x.year
month = lambda x: x.month
day = lambda x: x.day
t = lambda x: x.time()
print(year(now))
print(month(now))
print(day(now))
print(t(now))

'''
2022-05-08 09:58:33.843320
2022
5
8
09:58:33.843320
'''

8、使用 Lambda 创建 Fibonacci

编写一个Python程序，使用Lambda创建Fibonacci系列，直到n。

from functools import reduce
 
fib_series = lambda n: reduce(lambda x, _: x+[x[-1]+x[-2]],
                                range(n-2), [0, 1])
 
print("Fibonacci series upto 2:")
print(fib_series(2))
print("\nFibonacci series upto 5:")
print(fib_series(5))
print("\nFibonacci series upto 6:")
print(fib_series(6))
print("\nFibonacci series upto 9:")
print(fib_series(9))

'''
Fibonacci series upto 2:
[0, 1]

Fibonacci series upto 5:
[0, 1, 1, 2, 3]

Fibonacci series upto 6:
[0, 1, 1, 2, 3, 5]

Fibonacci series upto 9:
[0, 1, 1, 2, 3, 5, 8, 13, 21]
'''

【2】reduce

reduce的语法格式

reduce(function, sequence[, initial]) -> value

reduce函数接受一个function和一串sequence，并返回单一的值，以如下方式计算：

• 初始，function被调用，并传入sequence的前两个items，计算得到result并返回
• function继续被调用，并传入上一步中的result，和sequence种下一个item，计算得到result并返回。一直重复这个操作，直到sequence都被遍历完，返回最终结果。
• initial：指定的初始值
  注意1： 当initial值被指定时，传入step1中的两个参数分别是initial值和sequence的第一个items。reduce()最多只能接受三个参数，func，sequence，initial。
  注意2：在python2中reduce时内置函数，但是在python3中，它被移到functools模块，因此使用之前需要导入。

9、使用 Lambda 查找两个给定数组的交集

编写一个 Python 程序，使用 Lambda 查找两个给定数组的交集。

array_nums1 = [1, 2, 3, 5, 7, 8, 9, 10]
array_nums2 = [1, 2, 4, 8, 9]
print("Original arrays:")
print(array_nums1)
print(array_nums2)
result = list(filter(lambda x: x in array_nums1, array_nums2)) 
# 这里的第二个参数是filter的参数
print ("\nIntersection of the said arrays: ",result)

'''
Original arrays:
[1, 2, 3, 5, 7, 8, 9, 10]
[1, 2, 4, 8, 9]

Intersection of the said arrays:  [1, 2, 8, 9]
'''

10、使用 Lambda 对数组中奇偶数进行计数

编写一个 Python 程序，以使用 Lambda 重新排列给定数组中的正数和负数。

array_nums = [1, 2, 3, 5, 7, 8, 9, 10]
print("Original arrays:")
print(array_nums)
odd_ctr = len(list(filter(lambda x: (x%2 != 0) , array_nums)))
even_ctr = len(list(filter(lambda x: (x%2 == 0) , array_nums)))
print("\nNumber of even numbers in the above array: ", even_ctr)
print("\nNumber of odd numbers in the above array: ", odd_ctr)

'''
Original arrays:
[1, 2, 3, 5, 7, 8, 9, 10]

Number of even numbers in the above array:  3

Number of odd numbers in the above array:  5
'''

11、使用 Lambda 在给定列表中查找长度为 6 的值

编写一个 Python 程序，以使用 Lambda 查找给定列表中长度为 6 的值。

weekdays = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']
days = filter(lambda day: day if len(day)==6 else '', weekdays)
for d in days:
  print(d)

'''
Monday
Friday
Sunday
'''

12、使用map和lambda添加两个给定列表

编写一个Python程序，使用map和lambda添加两个给定的列表。

nums1 = [1, 2, 3]
nums2 = [4, 5, 6]
print("Original list:")
print(nums1)
print(nums2)
result = map(lambda x, y: x + y, nums1, nums2)
print("\nResult: after adding two list")
print(list(result))

'''
Original list:
[1, 2, 3]
[4, 5, 6]

Result: after adding two list
[5, 7, 9]
'''

【3】map

map是python内置函数，会根据提供的函数对指定的序列做映射。
map()函数的格式是：

map(function,iterable,...)

1、第一个参数接受一个函数名，后面的参数接受一个或多个可迭代的序列，返回的是一个集合。

2、把函数依次作用在list中的每一个元素上，得到一个新的list并返回。

3、map不改变原list，而是返回一个新list。

13、使用 Lambda 查找可被19或13整除的数字

编写一个Python程序，从使用Lambda的数字列表中查找可被十九或十三整除的数字。

nums = [19, 65, 57, 39, 152, 639, 121, 44, 90, 190]
print("Orginal list:")
print(nums) 
result = list(filter(lambda x: (x % 19 == 0 or x % 13 == 0), nums)) 
print("\nNumbers of the above list divisible by nineteen or thirteen:")
print(result)

'''
Orginal list:
[19, 65, 57, 39, 152, 639, 121, 44, 90, 190]

Numbers of the above list divisible by nineteen or thirteen:
[19, 65, 57, 39, 152, 190]
'''

14、使用 Lambda 在字符串列表中查找回文

编写一个 Python 程序，以使用 Lambda 在给定的字符串列表中查找回文。

根据维基百科 - 回文数字或数字回文是当其数字反转时保持不变的数字。例如，像16461一样，它是“对称的”。术语回文源自回文，回文是指一个单词（如转子或赛车），当其字母颠倒时，其拼写保持不变。前 30 个回文数字（十进制）分别为：0、1、2、3、4、5、6、7、8、9、11、22、33、44、55、66、77、88、99、101、111、121、131、141、151、161、171、181、191、202,…

texts = ["php", "w3r", "Python", "abcd", "Java", "aaa"]
print("Orginal list of strings:")
print(texts) 
result = list(filter(lambda x: (x == "".join(reversed(x))), texts)) 
print("\nList of palindromes:")
print(result) 

'''
Orginal list of strings:
['php', 'w3r', 'Python', 'abcd', 'Java', 'aaa']

List of palindromes:
['php', 'aaa']
'''

【4】join

描述：python join() 方法用于将序列中的元素以指定的字符连接生成一个新的字符串。

语法：str . join ( sequence )

参数：sequence – 要连接的元素序列。

返回值：返回通过指定字符连接序列中元素后生成的新字符串。

15、使用 lambda 函数将给定列表乘以给定数量

编写一个Python程序，使用lambda函数将给定列表的每个数量乘以给定数字。打印结果。
方法一：返回的是str类型的

nums = [2, 4, 6, 9 , 11]
n=2
print("Original list: ", nums)
print("Given number: ",2)
filtered_numbers=list(map(lambda number:number*n,nums))
print("Result:")
print(' '.join(map(str,filtered_numbers))) #变成str类型

'''
Original list:  [2, 4, 6, 9, 11]
Given number:  2
Result:
4 8 12 18 22
'''

方法二：简易版，返回的是list类型的，n为给定数字

a=[1,2,3,4]
n=2
b=list(map(lambda num:num*n,a))
print(b) 

'''
[2, 4, 6, 8]
'''

【5】将列表变成字符串

使用map和join函数

nums = [2, 4, 6, 9 , 11]
print(nums)
print(' '.join(map(str,nums)))
print(type(' '.join(map(str,nums))))

'''
[2, 4, 6, 9, 11]
2 4 6 9 11
<class 'str'>
'''

16、查找给定字符串的数字并将其存储在列表中

编写一个Python程序来查找给定字符串的数字并将其存储在列表中，以排序形式显示大于列表长度的数字。使用 lambda 函数来解决问题。

str1 = "sdf 23 safs8 5 sdfsd8 sdfs 56 21sfs 20 5"
print("Original string: ",str1)
str_num=[i for i in str1.split(' ')]
lenght=len(str_num)
numbers=sorted([int(x) for x in str_num if x.isdigit()])
print('Numbers in sorted form:')
for i in ((filter(lambda x:x>lenght,numbers))):
    print(i,end=' ')
    
'''
Original string:  sdf 23 safs8 5 sdfsd8 sdfs 56 21sfs 20 5
Numbers in sorted form:
20 23 56 
'''

【6】split

本文讲述的是string.split(s[, sep[, maxsplit]])，针对string类型的split()函数。

• 主要是切割字符串
• 结果返回由字符串元素组成的一个列表
• 当没有参数的情况下，函数默认会以空格，回车符，空格符等作为分割条件

17、使用 lambda 函数从列表中删除 None 值

这里判断是否是None值使用的是：v is not None

def remove_none(nums):
    result = filter(lambda v: v is not None, nums)
    return list(result)

nums = [12, 0, None, 23, None, -55, 234, 89, None, 0, 6, -12]
print("Original list:")
print(nums)
print("\nRemove None value from the said list:")
print(remove_none(nums))


'''
Original list:
[12, 0, None, 23, None, -55, 234, 89, None, 0, 6, -12]

Remove None value from the said list:
[12, 0, 23, -55, 234, 89, 0, 6, -12]
'''

18、使用 lambda 查找给定元组列表中最值

def max_min_list_tuples(class_students):
    return_max = max(class_students,key=lambda item:item[1])[1]
    return_min = min(class_students,key=lambda item:item[1])[1]
    return return_max, return_min
    
class_students = [('V', 62), ('VI', 68), ('VII', 72), ('VIII', 70), ('IX', 74), ('X', 65)]
print("Original list with tuples:")
print(class_students)
print("\nMaximum and minimum values of the said list of tuples:")
print(max_min_list_tuples(class_students))

'''
Original list with tuples:
[('V', 62), ('VI', 68), ('VII', 72), ('VIII', 70), ('IX', 74), ('X', 65)]

Maximum and minimum values of the said list of tuples:
(74, 62)
'''

19、使用 lambda 对给字符串(数字)排序

编写一个Python程序，使用lambda以数字方式对给定的字符串（数字）列表进行排序。

def sort_numeric_strings(nums_str):
    result = sorted(nums_str, key=lambda x: int(x))
    return result
nums_str = ['4','12','45','7','0','100','200','-12','-500']
print("Original list:")
print(nums_str)
print("\nSort the said list of strings(numbers) numerically:")
print(sort_numeric_strings(nums_str))

'''
Original list:
['4', '12', '45', '7', '0', '100', '200', '-12', '-500']

Sort the said list of strings(numbers) numerically:
['-500', '-12', '0', '4', '7', '12', '45', '100', '200']
'''

20、使用 lambda 将字符串转换为元组中的整数

def tuple_int_str(tuple_str):
    result = tuple(map(lambda x: (int(x[0]), int(x[2])), tuple_str))
    return result     
tuple_str =  (('233', 'ABCD', '33'), ('1416', 'EFGH', '55'), ('2345', 'WERT', '34'))
print("Original tuple values:")
print(tuple_str)
print("\nNew tuple values:")
print(tuple_int_str(tuple_str))

'''
Original tuple values:
(('233', 'ABCD', '33'), ('1416', 'EFGH', '55'), ('2345', 'WERT', '34'))

New tuple values:
((233, 33), (1416, 55), (2345, 34))
'''

21、使用 lambda 从列表中删除另外列表的元素

编写一个 Python 程序，使用 lambda 从另一个列表中存在的给定列表中删除所有元素。

def index_on_inner_list(list1, list2):
    result = list(filter(lambda x: x not in list2, list1))
    # 表示在list1当中，但是不在list2当中的
    return result
list1 = [1,2,3,4,5,6,7,8,9,10]
list2 = [2,4,6,8]
print("Original lists:")
print("list1:", list1)
print("list2:", list2)
print("\nRemove all elements from 'list1' present in 'list2:")
print(index_on_inner_list(list1, list2))

'''
Original lists:
list1: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
list2: [2, 4, 6, 8]

Remove all elements from 'list1' present in 'list2:
[1, 3, 5, 7, 9, 10]
'''