匿名函數

目錄

• 1、有名函數
• 2、匿名函數
• 3、與內置函數聯用
• 4、自定義sorted方法
• 5、習題
• for i in user_info_list:
• print(i)
• 1.
• 2.
• 3.
• 4.
• print(list(filter(lambda item: not(item['name'].startswith('a')), user_info_list)))

1、有名函數

咱們以前定的函數都是有名函數，它是基於函數名使用。

def func():
    print('from func')


func()
func()
func()
print(func)

from func
from func
from func
<function func at 0x10518b268>

2、匿名函數

匿名函數，他沒有綁定名字，使用一次即被收回，加括號既能夠運行。

lambda x, y: x+y

<function __main__.<lambda>(x, y)>

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

3

3、與內置函數聯用

匿名函數一般與max()、sorted()、filter()、sorted()方法聯用。

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

1.若是咱們想從上述字典中取出薪資最高的人，咱們可使用max()方法，可是max()默認比較的是字典的key。

1. 首先將可迭代對象變成迭代器對象
2. res=next(迭代器對象)，將res當作參數傳給key指定的函數，而後將該函數的返回值當作判斷依據

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

print(f"max(salary_dict): {max(salary_dict)}")


def func(k):
    return salary_dict[k]


print(f"max(salary_dict, key=func()): {max(salary_dict, key=func)}")
# 'nick', v1 = func('nick')
# 'jason', v2 = func('jason')
# 'tank', v3 = func('tank')
# 'sean', v4 = func('sean')


print(
    f"max(salary_dict, key=lambda name: salary_dict[name]): {max(salary_dict, key=lambda name: salary_dict[name])}")

max(salary_dict): tank
max(salary_dict, key=func()): jason
max(salary_dict, key=lambda name: salary_dict[name]): jason

2.若是咱們想對上述字典中的人，按照薪資從大到小排序，可使用sorted()方法。

sorted()工做原理：

1. 首先將可迭代對象變成迭代器對象
2. res=next(迭代器對象)，將res當作參數傳給第一個參數指定的函數，而後將該函數的返回值當作判斷依據。

lis = [1, 3, 2, 5, 8, 6]
sorted(lis)
print(f"lis: {lis}")
print(f"sorted(lis,reverse=True): {sorted(lis,reverse=True)}")

lis: [1, 3, 2, 5, 8, 6]
sorted(lis,reverse=True): [8, 6, 5, 3, 2, 1]

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

print(
    f"sorted(salary_dict, key=lambda name: salary_dict[name]): {sorted(salary_dict, key=lambda name: salary_dict[name])}")

sorted(salary_dict, key=lambda name: salary_dict[name]): ['sean', 'nick', 'tank', 'jason']

3.若是咱們想對一個列表中的某我的名作處理，可使用map()方法。

map()工做原理：

1. 首先將可迭代對象變成迭代器對象
2. res=next(迭代器對象)，將res當作參數傳給第一個參數指定的函數，而後將該函數的返回值做爲map()方法的結果之一。

name_list = ['jason', 'tank', 'sean']

res = map(lambda name: f"{name} sb", name_list)
print(f"list(res): {list(res)}")

list(res): ['jason sb', 'tank sb', 'sean sb']

4.若是咱們想篩選除名字中含有'sb'的名字，咱們可使用filter()方法。

filter()工做原理：

1. 首先將可迭代對象變成迭代器對象
2. res=next(迭代器對象)，將res當作參數傳給第一個參數指定的函數，而後filter會判斷函數的返回值的真假，若是爲真則留下。

name_list = ['nick', 'jason sb', 'tank sb', 'sean sb']

filter_res = filter(lambda name: name.endswith('sb'), name_list)
print(f"list(filter_res): {list(filter_res)}")

list(filter_res): ['jason sb', 'tank sb', 'sean sb']

4、自定義sorted方法

# 不太熟悉的同窗不要看(有興趣的能夠看一看)
def sorted(iter, key=None, reverse=None):
    iter.sort()

    if key:
        # key 是一個函數對象
        lt = []
        lt2 = []
        for i in iter:
            res = key(i)
            lt.append(res)
            lt2.append(i)
        lt.sort()

        lt3 = []
        for i in lt:
            for j in lt2:
                if j[1] == i:
                    lt3.append(j)

        if reverse:
            lt3.reverse()
        return lt3

    if reverse:
        iter.reverse()
    return iter


salary_list = list(salary_dict.items())
print(salary_list) # [('nick', 3000), ('jason', 100000), ('tank', 5000), ('sean', 2000), ('z', 1000)]
print(sorted(salary_list, key=lambda i: i[1],
             reverse=None))  # [('sean', 2000), ('nick', 3000), ('tank', 5000), ('jason', 100000)]

5、習題

```python
'''

1. 文件內容以下,標題爲:姓名,性別,年紀,薪資

姓名,性別,年紀,薪資
nick male 18 3000
ajson male 38 30000
sean female 28 20000
tank female 28 10000

要求:
從文件中取出每一條記錄nick male 18 3000放入列表中，
列表的每一個元素都是{'name':'nick','sex':'male','age':18,'salary':3000}的形式

1. 根據1獲得的列表，取出薪資最高的人的信息
2. 根據1獲得的列表，取出最年輕的人的信息
3. 根據1獲得的列表，將每一個人的信息中的名字映射成首字母大寫的形式
4. 根據1獲得的列表，過濾掉名字以a開頭的人的信息

'''

user_info_list = []
with open('user_info.txt', 'r', encoding='utf8') as fr:
for user_info in fr: # type:str
# print(user_info.strip().split(' '))
user_info_split = user_info.strip().split(' ')
name, sex, age, salary = user_info_split
user_info_dict = {'name': name, 'sex': sex, 'age': age, 'salary': salary}
# user_info_dict = {'name':user_info_split[0],'sex':user_info_split[1],'age':user_info_split[2],'salary':user_info_split[3]}
# user_info_dict = {k: v for k, v in zip(['name', 'sex', 'age', 'salary'], user_info_split)}
user_info_list.append(user_info_dict)

for i in user_info_list:

print(i)

'''

1. 根據1獲得的列表，取出薪資最高的人的信息
2. 根據1獲得的列表，取出最年輕的人的信息
3. 根據1獲得的列表，將每一個人的信息中的名字映射成首字母大寫的形式
4. 根據1獲得的列表，過濾掉名字以a開頭的人的信息

[
{'name': 'nick', 'sex': 'male', 'age': '18', 'salary': '3000'}
{'name': 'ajson', 'sex': 'male', 'age': '38', 'salary': '30000'}
{'name': 'sean', 'sex': 'female', 'age': '28', 'salary': '20000'}
{'name': 'tank', 'sex': 'female', 'age': '28', 'salary': '10000'}]
'''

1.

print(max(user_info_list, key=lambda item: item['salary']))
max_salary = 0
user_info_str = ''
for user_info in user_info_list:
if int(user_info['salary']) > max_salary:
max_salary = int(user_info['salary'])
user_info_str = user_info
print(1, user_info_str)

2.

print(min(user_info_list, key=lambda item: item['age']))

3.

print(list(map(lambda item: item['name'].title(), user_info_list)))

4.

print(list(filter(lambda item: not(item['name'].startswith('a')), user_info_list)))

for user_info in user_info_list: # type:dict if user_info['name'].startswith('a'): user_info_list.remove(user_info) print(user_info_list) ```