lambda函数

也就是匿名函数，函数没有具体的名称，比如对一个函数:

1
2
def compare(item):
    return item[1]

该函数传入一个名为item的可迭代对象，返回值为其中元素索引为1的值，lambda函数就可以写成lambda item:item[1]。

sorted函数参数key

1
sorted(iterable, key=None, reverse=False)
  • iterable: 待排序的可迭代对象，列表、元组、字符串、集合、字典。
  • key(可选): 一个可调用的函数，用于指定排序的方式，默认为None，代表按照元素的自然顺序进行排序。
  • reverse(可选): 一个布尔值，如果为True，则按照降序排列，反之则为默认值False按照升序排序。
1
2
3
4
5
6
7
8
9
10
11
12
def compare(item):
    return item[1]

lst=[
    (1,0),
    (2,-1),
    (0,2),
    (3,1)
]
# 使用 compare 函数对集合进行排序，按照元组的第二个元素排序
sorted_lst=sorted(lst,key=compare)
# [(2, -1), (1, 0), (3, 1), (0, 2)]

compare() 函数将传递给 sorted() 函数的元素 item 解包并返回第二个元素，用作排序的关键。若使用lambda函数，可以这样写:

1
2
3
4
5
6
7
8
9
lst=[
    (1,0),
    (2,-1),
    (0,2),
    (3,1)
]

sorted_lst=sorted(lst,key=lambda item:item[1])
# [(2, -1), (1, 0), (3, 1), (0, 2)]

刷题

前天的打卡作业是这样的：给定一个正整数，统计该正整数中，出现次数最多的数字，如果有多个，按照数字排序后输出。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
from collections import defaultdict
numbers=input("A positive integer please: ")
numbers_list=list(map(int,numbers.split()))
numbers_dict=defaultdict(int)
for number in numbers:
    numbers_dict[number]+=1
print(numbers_dict)
sorted_list=sorted(numbers_dict.items(),key=lambda item:item[1],reverse=True)
print(sorted_list)
# 获取最多出现次数
max_cnt=sorted_list[0][1]
# 利用列表推导式筛选出现次数最多的数字并按数字排序
most_frequent_numbers=[item[0] for item in sorted_list if item[1]==max_cnt]
output_str = f"出现次数最多的是{', '.join(map(str, most_frequent_numbers))}，次数为{max_cnt}"
print(output_str)
# A positive integer please: 231321453451
# defaultdict(<class 'int'>, {'2': 2, '3': 3, '1': 3, '4': 2, '5': 2})
# [('3', 3), ('1', 3), ('2', 2), ('4', 2), ('5', 2)]
# 出现次数最多的是3, 1，次数为3

问题来了：求出现最多的次数的数字，所对应的索引的位置。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
from collections import defaultdict
numbers=input("A positive integer please: ")
numbers_list=list(map(int,numbers.split()))
numbers_dict=defaultdict(list)
for index,number in enumerate(numbers):
    numbers_dict[number].append(index)
print(numbers_dict)
sorted_list=sorted(numbers_dict.items(),key=lambda item:len(item[1]),reverse=True)
print(sorted_list)
for key,value in sorted_list:
    print(key,value)
max_cnt=len(sorted_list[0][1])
for item in sorted_list:
    if len(item[1])==max_cnt:
        print(f"出现次数最多的数字有{item[0]}, 索引位置为{', '.join(map(str,item[1]))}")
# A positive integer please: 231321453451
# defaultdict(<class 'list'>, {'2': [0, 4], '3': [1, 3, 8], '1': [2, 5, 11], '4': [6, 9], '5': [7, 10]})
# [('3', [1, 3, 8]), ('1', [2, 5, 11]), ('2', [0, 4]), ('4', [6, 9]), ('5', [7, 10])]
# 3 [1, 3, 8]
# 1 [2, 5, 11]
# 2 [0, 4]
# 4 [6, 9]
# 5 [7, 10]
# 出现次数最多的数字有3, 索引位置为1, 3, 8
# 出现次数最多的数字有1, 索引位置为2, 5, 11
https://leetcode.com/problems/contains-duplicate/
https://leetcode.com/problems/contains-duplicate/

分析题目，给定一个整型数组，如果任何值出现至少两次则返回true，否则返回false。

使用字典

1
2
3
4
5
6
7
8
9
10
11
12
def containsDuplicate(nums):
    nums_dict={}
    for num in nums:
        if num in nums_dict:
            return True
        else:
            nums_dict[num]=1
    return False

nums=[1,2,3,1]
print(containsDuplicate(nums))
# True

或者，使用集合

1
2
3
4
5
6
7
8
9
10
11
12
def containsDuplicate(nums):
    numbers_set=set()
    for num in nums:
        if num in numbers_set:
            return True
        else:
            numbers_set.add(num)
    return False

nums=[1,2,3]
print(containsDuplicate(nums))
# False

进制转化

1
2
3
4
5
6
7
8
9
10
def convert_base(num,base=2):
    res=""
    while num:
        # res+=str(num%base)
        # num=num//base
        num,digit=divmod(num,base)
        res+=str(digit)
    return res[::-1]

print(convert_base(12).rjust(8,'0'))

使用列表存储结果

1
2
3
4
5
6
7
8
def convert_base(num,base=2):
    res=[]
    while num:
        num,digit=divmod(num,base)
        res.insert(0,digit)
    return ''.join(map(str,res))

print(convert_base(12).rjust(8,'0'))

函数 rjust() 是一个字符串方法，用于将字符串右对齐，并在左侧填充指定的字符，以达到指定的宽度。

rjust(8, '0') 将转换后的结果字符串右对齐，并使用字符 0 在左侧填充，以使字符串的总宽度为 8。

快来参与讨论吧~