文章目录

一、集合1.集合的创建2.访问集合中的值3.集合的内置方法4.集合的转换5.不可变集合集合练习题 二、序列1.针对序列的内置函数序列练习题 三、函数与Lambda表达式1.函数函数的定义 1.函数2.函数的调用3.函数文档4.函数参数（重点）5.函数的返回值6.变量作用域7.Lambda表达式函数与Lambda表达式练习题

---

一、集合

Python 中set与dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key。

注意，key为不可变类型，即可哈希的值。

【例子】

num = {} print(type(num)) # <class 'dict'> num = {1, 2, 3, 4} #这个是dict有所区别，dict是有关键字和值的 print(type(num)) # <class 'set'>

1.集合的创建

先创建对象再加入元素。在创建空集合的时候只能使用s = set()，因为s = {}创建的是空字典。

【例子】

basket = set() #创建空集合 basket.add('apple') basket.add('banana') print(basket) # {'banana', 'apple'} 直接把一堆元素用花括号括起来{元素1, 元素2, ..., 元素n}。重复元素在set中会被自动被过滤。

【例子】

basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'} print(basket) # {'banana', 'apple', 'pear', 'orange'} 使用set(value)工厂函数，把列表或元组转换成集合。

【例子】

a = set('abracadabra') print(a) # {'r', 'b', 'd', 'c', 'a'} b = set(("Google", "Lsgogroup", "Taobao", "Taobao"))#set()把元组转换成集合 print(b) # {'Taobao', 'Lsgogroup', 'Google'} c = set(["Google", "Lsgogroup", "Taobao", "Google"])#把列表转换为集合 print(c) # {'Taobao', 'Lsgogroup', 'Google'}

【例子】去掉列表中重复的元素

lst = [0, 1, 2, 3, 4, 5, 5, 3, 1] temp = [] for item in lst: #用 not in 的方法，逻辑性要求比较高 if item not in temp: temp.append(item) print(temp) # [0, 1, 2, 3, 4, 5] a = set(lst) #用集合的方法简洁明了，先把列表转换成集合 print(list(a)) # [0, 1, 2, 3, 4, 5] 再把集合转换成列表

从结果发现集合的两个特点：无序 (unordered) 和唯一 (unique)。

由于 set 存储的是无序集合，所以我们不可以为集合创建索引或执行切片(slice)操作，也没有键(keys)可用来获取集合中元素的值，**但是可以判断一个元素是否在集合中

2.访问集合中的值

可以使用len()內建函数得到集合的大小。

【例子】

s = set(['Google', 'Baidu', 'Taobao']) print(len(s)) # 3 可以使用for把集合中的数据一个个读取出来。

【例子】

s = set(['Google', 'Baidu', 'Taobao']) for item in s: print(item) # Baidu # Google # Taobao 可以通过in或not in判断一个元素是否在集合中已经存在

3.集合的内置方法

set.add(elmnt)用于给集合添加元素，如果添加的元素在集合中已存在，则不执行任何操作。set.update(set)用于修改当前集合，可以添加新的元素或集合到当前集合中，如果添加的元素在集合中已存在，则该元素只会出现一次，重复的会忽略。

【例子】

x = {"apple", "banana", "cherry"} y = {"google", "baidu", "apple"} x.update(y) print(x) # {'cherry', 'banana', 'apple', 'google', 'baidu'} y.update(["lsgo", "dreamtech"]) print(y) # {'lsgo', 'baidu', 'dreamtech', 'apple', 'google'} set.remove(item) 用于移除集合中的指定元素。如果元素不存在，则会发生错误。set.discard(value) 用于移除指定的集合元素。remove() 方法在移除一个不存在的元素时会发生错误，而 discard() 方法不会。set.pop() 用于随机移除一个元素。

【例子】

fruits = {"apple", "banana", "cherry"} x = fruits.pop() print(fruits) # {'cherry', 'apple'} print(x) # banana

由于 set 是无序和无重复元素的集合，所以两个或多个 set 可以做数学意义上的集合操作。

set.intersection(set1, set2) 返回两个集合的交集。set1 & set2 返回两个集合的交集。set.intersection_update(set1, set2) 交集，在原始的集合上移除不重叠的元素。 a = set('abracadabra') b = set('alacazam') print(a) # {'r', 'a', 'c', 'b', 'd'} print(b) # {'c', 'a', 'l', 'm', 'z'} c = a.intersection(b) print(c) # {'a', 'c'} print(a & b) # {'c', 'a'} print(a) # {'a', 'r', 'c', 'b', 'd'} a.intersection_update(b) print(a) # {'a', 'c'} set.union(set1, set2) 返回两个集合的并集。set1 | set2 返回两个集合的并集。

【例子】

a = set('abracadabra') b = set('alacazam') print(a) # {'r', 'a', 'c', 'b', 'd'} print(b) # {'c', 'a', 'l', 'm', 'z'} print(a | b) # {'l', 'd', 'm', 'b', 'a', 'r', 'z', 'c'} c = a.union(b) print(c) # {'c', 'a', 'd', 'm', 'r', 'b', 'z', 'l'} set.difference(set) 返回集合的差集。set1 - set2 返回集合的差集。set.difference_update(set) 集合的差集，直接在原来的集合中移除元素，没有返回值。

【例子】

a = set('abracadabra') b = set('alacazam') print(a) # {'r', 'a', 'c', 'b', 'd'} print(b) # {'c', 'a', 'l', 'm', 'z'} c = a.difference(b) print(c) # {'b', 'd', 'r'} print(a - b) # {'d', 'b', 'r'} print(a) # {'r', 'd', 'c', 'a', 'b'} a.difference_update(b) print(a) # {'d', 'r', 'b'} set.symmetric_difference(set)返回集合的异或。set1 ^ set2 返回集合的异或。set.symmetric_difference_update(set)移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。 a = set('abracadabra') b = set('alacazam') print(a) # {'r', 'a', 'c', 'b', 'd'} print(b) # {'c', 'a', 'l', 'm', 'z'} c = a.symmetric_difference(b) print(c) # {'m', 'r', 'l', 'b', 'z', 'd'} print(a ^ b) # {'m', 'r', 'l', 'b', 'z', 'd'} print(a) # {'r', 'd', 'c', 'a', 'b'} a.symmetric_difference_update(b) print(a) # {'r', 'b', 'm', 'l', 'z', 'd'} set.issubset(set)判断集合是不是被其他集合包含，如果是则返回 True，否则返回 False。set1 <= set2 判断集合是不是被其他集合包含，如果是则返回 True，否则返回 False。

【例子】

x = {"a", "b", "c"} y = {"f", "e", "d", "c", "b", "a"} z = x.issubset(y) print(z) # True print(x <= y) # True x = {"a", "b", "c"} y = {"f", "e", "d", "c", "b"} z = x.issubset(y) print(z) # False print(x <= y) # False set.issuperset(set)用于判断集合是不是包含其他集合，如果是则返回 True，否则返回 False。set1 >= set2 判断集合是不是包含其他集合，如果是则返回 True，否则返回 False。

【例子】

x = {"f", "e", "d", "c", "b", "a"} y = {"a", "b", "c"} z = x.issuperset(y) print(z) # True print(x >= y) # True x = {"f", "e", "d", "c", "b"} y = {"a", "b", "c"} z = x.issuperset(y) print(z) # False print(x >= y) # False set.isdisjoint(set) 用于判断两个集合是不是不相交，如果是返回 True，否则返回 False。

【例子】

x = {"f", "e", "d", "c", "b"} y = {"a", "b", "c"} z = x.isdisjoint(y) print(z) # False x = {"f", "e", "d", "m", "g"} y = {"a", "b", "c"} z = x.isdisjoint(y) print(z) # True

4.集合的转换

【例子】

se = set(range(4)) li = list(se) tu = tuple(se) print(se, type(se)) # {0, 1, 2, 3} <class 'set'> print(li, type(li)) # [0, 1, 2, 3] <class 'list'> print(tu, type(tu)) # (0, 1, 2, 3) <class 'tuple'>

5.不可变集合

Python 提供了不能改变元素的集合的实现版本，即不能增加或删除元素，类型名叫frozenset。需要注意的是frozenset仍然可以进行集合操作，只是不能用带有update的方法。

frozenset([iterable]) 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。

【例子】

a = frozenset(range(10)) # 生成一个新的不可变集合 print(a) # frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9}) b = frozenset('lsgogroup') print(b) # frozenset({'g', 's', 'p', 'r', 'u', 'o', 'l'})

集合练习题

怎么表示只包含⼀个数字1的元组。创建一个空集合，增加 {‘x’,‘y’,‘z’} 三个元素。列表[‘A’, ‘B’, ‘A’, ‘B’]去重。求两个集合{6, 7, 8}，{7, 8, 9}中不重复的元素（差集指的是两个集合交集外的部分）。求{‘A’, ‘B’, ‘C’}中元素在 {‘B’, ‘C’, ‘D’}中出现的次数。 x=(1,) #元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用 print(x) a=set() #创建一个空集合，增加 {‘x’,‘y’,‘z’} 三个元素 a.add('x') a.add('y') a.add('z') print(a) lst=['A','B','A','B'] se=set(lst) #列表转换成集合，因为集合可去重 print(list(se)) #集合转换成列表 se1={6, 7, 8} #用异或 se2={7, 8, 9} print(se1^se2) lst2=list({'A', 'B', 'C'}) #集合转换为列表 lst3=list({'B', 'C', 'D'}) #集合转换为列表 for i in lst2: print(i,lst3.count(i)) #计数 ''' (1,) {'y', 'z', 'x'} ['B', 'A'] {9, 6} B 1 A 0 C 1 '''

---

二、序列

在 Python 中，序列类型包括字符串、列表、元组、集合和字典，这些序列支持一些通用的操作，但比较特殊的是，集合和字典不支持索引、切片、相加和相乘操作。

1.针对序列的内置函数

list(sub) 把一个可迭代对象转换为列表。

tuple(sub) 把一个可迭代对象转换为元组。

str(obj) 把obj对象转换为字符串

len(s) 返回对象（字符、列表、元组等）长度或元素个数。 s – 对象。 -max(sub)返回序列或者参数集合中的最大值

min(sub)返回序列或参数集合中的最小值

sum(iterable[, start=0]) 返回序列iterable与可选参数start的总和。

sorted(iterable, key=None, reverse=False) 对所有可迭代的对象进行排序操作。

①iterable – 可迭代对象。 ②key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。 ③reverse – 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。 ④返回重新排序的列表。

【例子】

x = [-8, 99, 3, 7, 83] print(sorted(x)) # [-8, 3, 7, 83, 99] print(sorted(x, reverse=True)) # [99, 83, 7, 3, -8] t = ({"age": 20, "name": "a"}, {"age": 25, "name": "b"}, {"age": 10, "name": "c"}) x = sorted(t, key=lambda a: a["age"]) # 主要是用字典关键字age中的值进行比较,默认升序 print(x) # [{'age': 10, 'name': 'c'}, {'age': 20, 'name': 'a'}, {'age': 25, 'name': 'b'}]

关于lambda函数，请参考：关于Python中的lambda，这篇阅读量10万+的文章可能是你见过的最完整的讲解

reversed(seq) 函数返回一个反转的迭代器。 ① seq – 要转换的序列，可以是 tuple, string, list 或 range。

【例子】注意看：以下例子均使用list()把反转结果取出来

s = 'lsgogroup' x = reversed(s) print(type(x)) # <class 'reversed'> print(x) # <reversed object at 0x000002507E8EC2C8> print(list(x)) #用list()把反转结果取出来 # ['p', 'u', 'o', 'r', 'g', 'o', 'g', 's', 'l'] t = ('l', 's', 'g', 'o', 'g', 'r', 'o', 'u', 'p') print(list(reversed(t))) # ['p', 'u', 'o', 'r', 'g', 'o', 'g', 's', 'l'] r = range(5, 9) print(list(reversed(r))) # [8, 7, 6, 5] x = [-8, 99, 3, 7, 83] print(list(reversed(x))) # [83, 7, 3, 99, -8] enumerate(sequence, [start=0])

【例子】用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。

seasons = ['Spring', 'Summer', 'Fall', 'Winter'] a = list(enumerate(seasons)) print(a) # [(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')] b = list(enumerate(seasons, 1)) print(b) # [(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')] for i, element in a: print('{0},{1}'.format(i, element)) # 0,Spring # 1,Summer # 2,Fall # 3,Winter zip(iter1 [,iter2 [...]]) 用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象，这样做的好处是节约了不少的内存。我们可以使用 list() 转换来输出列表。如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。

【例子】

a = [1, 2, 3] b = [4, 5, 6] c = [4, 5, 6, 7, 8] zipped = zip(a, b) print(zipped) # <zip object at 0x000000C5D89EDD88> print(list(zipped)) # [(1, 4), (2, 5), (3, 6)] zipped = zip(a, c) print(list(zipped)) # [(1, 4), (2, 5), (3, 6)] a1, a2 = zip(*zip(a, b)) print(list(a1)) # [1, 2, 3] print(list(a2)) # [4, 5, 6]

序列练习题

1.怎么找出序列中的最⼤、⼩值？

a = [4, 5, 6, 7, 8] print(max(a)) print(min(a)) #8 #4

2.sort() 和 sorted() 区别

list1.sort() #list1排序发生改变 list2=sorted(list1) #list1未发生变化，list2为排序好的list1

详细请参考：python sort与sorted使用笔记

3.怎么快速求 1 到 100 所有整数相加之和？

b = list(range(101)) sum = 0 for i in b : sum = sum +i print(sum) #5050

4.求列表 [2,3,4,5] 中每个元素的立方根。

lst = [2,3,4,5] c = 0 for i in lst: c = i**3 print(c) ''' 8 27 64 125 '''

5.将[‘x’,‘y’,‘z’] 和 [1,2,3] 转成 [(‘x’,1),(‘y’,2),(‘z’,3)] 的形式

lst1 = ['x','y','z'] lst2 = [1,2,3] zipped = zip(lst1,lst2) print(zipped) print(list(zipped)) #<zip object at 0x00000000026B1680> #[('x', 1), ('y', 2), ('z', 3)]

---

三、函数与Lambda表达式

1.函数

还记得 Python 里面“万物皆对象”么？Python 把函数也当成对象，可以从另一个函数中返回出来而去构建高阶函数，比如：

参数是函数返回值是函数

函数的定义

1.函数

函数以def关键词开头，后接函数名和圆括号()。函数执行的代码以冒号起始，并且缩进。return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回None。 def functionname(parameters): "函数_文档字符串" function_suite return [expression]

2.函数的调用

【例子】

def printme(str): print(str) printme("我要调用用户自定义函数!") # 我要调用用户自定义函数! printme("再次调用同一函数") # 再次调用同一函数 temp = printme('hello') # hello print(temp) # None

3.函数文档

def MyFirstFunction(name): "函数定义过程中name是形参" # 因为Ta只是一个形式，表示占据一个参数位置 print('传递进来的{0}叫做实参，因为Ta是具体的参数值！'.format(name)) MyFirstFunction('老马的程序人生') # 传递进来的老马的程序人生叫做实参，因为Ta是具体的参数值！ print(MyFirstFunction.__doc__) # 函数定义过程中name是形参 help(MyFirstFunction) # Help on function MyFirstFunction in module __main__: # MyFirstFunction(name) # 函数定义过程中name是形参

4.函数参数（重点）

Python 的函数具有非常灵活多样的参数形态，既可以实现简单的调用，又可以传入非常复杂的参数。从简到繁的参数形态如下：

位置参数 (positional argument)默认参数 (default argument)可变参数 (variable argument)关键字参数 (keyword argument)命名关键字参数 (name keyword argument)参数组合

1. 位置参数

def functionname(arg1): "函数_文档字符串" function_suite return [expression] arg1 - 位置参数 ，这些参数在调用函数 (call function) 时位置要固定。

2. 默认参数

def functionname(arg1, arg2=v): "函数_文档字符串" function_suite return [expression] arg2 = v - 默认参数 = 默认值，调用函数时，默认参数的值如果没有传入，则被认为是默认值。默认参数一定要放在位置参数 后面，不然程序会报错。

【例子】

def printinfo(name, age=8): print('Name:{0},Age:{1}'.format(name, age)) printinfo('小马') # Name:小马,Age:8 printinfo('小马', 10) # Name:小马,Age:10 Python 允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。

【例子】

def printinfo(name, age): print('Name:{0},Age:{1}'.format(name, age)) printinfo(age=8, name='小马') # Name:小马,Age:8

3. 可变参数

顾名思义，可变参数就是传入的参数个数是可变的，可以是 0, 1, 2 到任意个，是不定长的参数。

def functionname(arg1, arg2=v, *args): "函数_文档字符串" function_suite return [expression] *args - 可变参数，可以是从零个到任意个，自动组装成元组。加了星号（*）的变量名会存放所有未命名的变量参数。

【例子】

def printinfo(arg1, *args): print(arg1) for var in args: print(var) printinfo(10) # 10 printinfo(70, 60, 50) # 70 # 60 # 50

4. 关键字参数

def functionname(arg1, arg2=v, *args, **kw): "函数_文档字符串" function_suite return [expression] **kw - 关键字参数，可以是从零个到任意个，自动组装成字典。

【例子】

def printinfo(arg1, *args, **kwargs): print(arg1) print(args) print(kwargs) printinfo(70, 60, 50) # 70 # (60, 50) # {} printinfo(70, 60, 50, a=1, b=2) # 70 # (60, 50) # {'a': 1, 'b': 2}

「可变参数」和「关键字参数」的同异总结如下：

可变参数允许传入零个到任意个参数，它们在函数调用时自动组装为一个元组 (tuple)。关键字参数允许传入零个到任意个参数，它们在函数内部自动组装为一个字典 (dict)。

5. 命名关键字参数

def functionname(arg1, arg2=v, *args, *, nkw, **kw): "函数_文档字符串" function_suite return [expression] *, nkw - 命名关键字参数，用户想要输入的关键字参数，定义方式是在nkw 前面加个分隔符 *。如果要限制关键字参数的名字，就可以用「命名关键字参数」使用命名关键字参数时，要特别注意不能缺少参数名。

【例子】

def printinfo(arg1, *, nkw, **kwargs): print(arg1) print(nkw) print(kwargs) printinfo(70, nkw=10, a=1, b=2) # 70 # 10 # {'a': 1, 'b': 2} printinfo(70, 10, a=1, b=2) # TypeError: printinfo() takes 1 positional argument but 2 were given 没有写参数名nwk，因此 10 被当成「位置参数」，而原函数只有 1 个位置函数，现在调用了 2 个，因此程序会报错。

6. 参数组合

在 Python 中定义函数，可以用位置参数、默认参数、可变参数、命名关键字参数和关键字参数，这 5 种参数中的 4 个都可以一起使用，但是注意，参数定义的顺序必须是：

位置参数、默认参数、可变参数和关键字参数。位置参数、默认参数、命名关键字参数和关键字参数。

要注意定义可变参数和关键字参数的语法：

*args 是可变参数，args 接收的是一个 tuple**kw 是关键字参数，kw 接收的是一个 dict

命名关键字参数是为了限制调用者可以传入的参数名，同时可以提供默认值。定义命名关键字参数不要忘了写分隔符 *，否则定义的是位置参数。

警告：虽然可以组合多达 5 种参数，但不要同时使用太多的组合，否则函数很难懂。

5.函数的返回值

【例子】

def add(a, b): return a + b print(add(1, 2)) # 3 print(add([1, 2, 3], [4, 5, 6])) # [1, 2, 3, 4, 5, 6]

【例子】

def back(): return [1, '小马的程序人生', 3.14] #返回的是一个list print(back()) # [1, '小马的程序人生', 3.14]

【例子】

def back(): return 1, '小马的程序人生', 3.14 #返回了一个tuple print(back()) # (1, '小马的程序人生', 3.14)

【例子】

def printme(str): print(str) temp = printme('hello') # hello print(temp) # None print(type(temp)) # <class 'NoneType'>

6.变量作用域

Python 中，程序的变量并不是在哪个位置都可以访问的，访问权限决定于这个变量是在哪里赋值的。定义在函数内部的变量拥有局部作用域，该变量称为局部变量。定义在函数外部的变量拥有全局作用域，该变量称为全局变量。局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。

【例子】

def discounts(price, rate): final_price = price * rate return final_price old_price = float(input('请输入原价:')) # 98 rate = float(input('请输入折扣率:')) # 0.9 new_price = discounts(old_price, rate) print('打折后价格是:%.2f' % new_price) # 88.20 当内部作用域想修改外部作用域的变量时，就要用到global和nonlocal关键字了。

【例子】

num = 1 def fun1(): global num # 需要使用 global 关键字声明 print(num) # 1 num = 123 print(num) # 123 fun1() print(num) # 123

内嵌函数

【例子】

def outer(): print('outer函数在这被调用') def inner(): print('inner函数在这被调用') inner() # 该函数只能在outer函数内部被调用 outer() # outer函数在这被调用 # inner函数在这被调用 def funX(x): def funY(y): return x * y #内部函数funY()里对外层非全局作用域的变量x进行引用 return funY i = funX(8) print(type(i)) # <class 'function'> print(i(5)) # 40

【例子】闭包的返回值通常是函数。

def make_counter(init): counter = [init] def inc(): counter[0] += 1 def dec(): counter[0] -= 1 def get(): return counter[0] def reset(): counter[0] = init return inc, dec, get, reset inc, dec, get, reset = make_counter(0) inc() inc() inc() print(get()) # 3 dec() print(get()) # 2 reset() print(get()) # 0

【例子】 如果要修改闭包作用域中的变量则需要 nonlocal 关键字

def outer(): num = 10 def inner(): nonlocal num # nonlocal关键字声明 num = 100 print(num) inner() print(num) outer() # 100 # 100

递归

如果一个函数在内部调用自身本身，这个函数就是递归函数。

【例子】n! = 1 x 2 x 3 x ... x n

# 利用循环 n = 5 for k in range(1, 5): n = n * k print(n) # 120 # 利用递归 def factorial(n): if n == 1: return 1 return n * factorial(n - 1) print(factorial(5)) # 120

【例子】斐波那契数列 f(n)=f(n-1)+f(n-2), f(0)=0 f(1)=1

# 利用循环 i = 0 j = 1 lst = list([i, j]) for k in range(2, 11): k = i + j lst.append(k) i = j j = k print(lst) # [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55] # 利用递归 def recur_fibo(n): if n <= 1: return n return recur_fibo(n - 1) + recur_fibo(n - 2) lst = list() for k in range(11): lst.append(recur_fibo(k)) print(lst) # [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]

【例子】设置递归的层数，Python默认递归层数为 100

import sys sys.setrecursionlimit(1000)

有关递归的详细介绍参见：

利用python解决汉诺塔问题？

7.Lambda表达式

匿名函数的定义

在 Python 里有两类函数：

第一类：用 def 关键词定义的正规函数第二类：用 lambda 关键词定义的匿名函数

python 使用 lambda 关键词来创建匿名函数，而非def关键词，它没有函数名，其语法结构如下：

lambda argument_list: expression lambda - 定义匿名函数的关键词。argument_list - 函数参数，它们可以是位置参数、默认参数、关键字参数，和正规函数里的参数类型一样。:- 冒号，在函数参数和表达式中间要加个冒号。expression - 只是一个表达式，输入函数参数，输出一些值。

注意：

expression 中没有 return 语句，因为 lambda 不需要它来返回，表达式本身结果就是返回值。匿名函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。

【例子】

def sqr(x): return x ** 2 print(sqr) # <function sqr at 0x000000BABD3A4400> y = [sqr(x) for x in range(10)] print(y) # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] lbd_sqr = lambda x: x ** 2 print(lbd_sqr) # <function <lambda> at 0x000000BABB6AC1E0> y = [lbd_sqr(x) for x in range(10)] print(y) # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] sumary = lambda arg1, arg2: arg1 + arg2 print(sumary(10, 20)) # 30 func = lambda *args: sum(args) print(func(1, 2, 3, 4, 5)) # 15

匿名函数的应用 函数式编程 是指代码中每一块都是不可变的，都由纯函数的形式组成。这里的纯函数，是指函数本身相互独立、互不影响，对于相同的输入，总会有相同的输出，没有任何副作用。

【例子】非函数式编程

def f(x): for i in range(0, len(x)): x[i] += 10 return x x = [1, 2, 3] f(x) print(x) # [11, 12, 13]

【例子】函数式编程

def f(x): y = [] for item in x: y.append(item + 10) return y x = [1, 2, 3] f(x) print(x) # [1, 2, 3]

匿名函数 常常应用于函数式编程的高阶函数 (high-order function)中，主要有两种形式：

参数是函数 (filter, map)返回值是函数 (closure)

如，在 filter和map函数中的应用：

filter(function, iterable) 过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，如果要转换为列表，可以使用 list() 来转换。

【例子】

odd = lambda x: x % 2 == 1 templist = filter(odd, [1, 2, 3, 4, 5, 6, 7, 8, 9]) print(list(templist)) # [1, 3, 5, 7, 9] map(function, *iterables) 根据提供的函数对指定序列做映射。

【例子】

m1 = map(lambda x: x ** 2, [1, 2, 3, 4, 5]) print(list(m1)) # [1, 4, 9, 16, 25] m2 = map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10]) print(list(m2)) # [3, 7, 11, 15, 19]

除了 Python 这些内置函数，我们也可以自己定义高阶函数。

【例子】

def apply_to_list(fun, some_list): return fun(some_list) lst = [1, 2, 3, 4, 5] print(apply_to_list(sum, lst)) # 15 print(apply_to_list(len, lst)) # 5 print(apply_to_list(lambda x: sum(x) / len(x), lst)) # 3.0

函数与Lambda表达式练习题

怎么给函数编写⽂档？ def a(name): '在此编写文档' print(a.__doc__)

2.怎么给函数参数和返回值注解？

调用函数时括号内用冒号标注输入类型，箭头后面标注返回值类型

def accumlate(x:int, y:int): #给函数参数注解 return x*y def accumlate(x:int, y:int) -> int: #给返回值注解 return x*y

闭包中，怎么对数字、字符串、元组等不可变元素更新。 用nonlocal 关键字

分别根据每一行的首元素和尾元素大小对二维列表 a = [[6, 5], [3, 7], [2, 8]] 排序。(利用lambda表达式)

a= [[6, 5], [3, 7], [2, 8]] b=sorted(a,key=(lambda x:x[0]))#用lambda表达式对二维列表以第一个元素排序 print(b) c=sorted(a,key=(lambda x:x[1]))#用lambda表达式对二维列表以第二个元素排序 print(c) 利用python解决汉诺塔问题？

有a、b、c三根柱子，在a柱子上从下往上按照大小顺序摞着64片圆盘，把圆盘从下面开始按大小顺序重新摆放在c柱子上，尝试用函数来模拟解决的过程。（提示：将问题简化为已经成功地将a柱上面的63个盘子移到了b柱）

(有答案，但是自己想不出来为啥哈哈哈~~~看懂的可以给我解释解释？哈哈哈红红火火恍恍惚惚

def hanoi(n, a, b, c): if n == 1: print(a, '-->', c) else: hanoi(n - 1, a, c, b) print(a, '-->', c) hanoi(n - 1, b, a, c) hanoi(64, 'A', 'B', 'C')