Python(六)-拆包,互换变量名,lambda

目次
拆包
互换变量值
引用
lambda函数
lambda实例
字典的lambda
推导式
列表推导式
列表推导式+if条件判断
for循环嵌套列表推导式
字典推导式
聚集推导式

---

拆包

看一下在Python步伐中的拆包：把组合形成的元组形式的数据，拆分出单个元素内容。
   变量名1,变量名2,... = 结果
   例
（1）在一个函数中，使用return返回求解两个数的和、差；
（2）使用items()方式遍历处置惩罚字典中存储的学生信息各个键与值；

1. # 1 定义函数: 返回两个参数的 和 与 差
2. def get_sum_sub(a, b):
3.     return a+b,a-b
5. # 2 调用
6. # 2.1 方式一 手动
7. result = get_sum_sub(10, 2)
8. print(result)
9. print(type(result))  # <class 'tuple'>
11. print(result[0])
12. print(result[1])
14. # 2.2 方式二 自动
15. res1,res2 = get_sum_sub(12, 2)
16. print(res1, '---->', res2)
18. # 3 遍历 字典
19. dict1 = {"name":"女儿国国王", "age":18, "skill":"XXX"}
21. # 3.1 方式一
22. for item in dict1.items():
23.     key = item[0]
24.     val = item[1]
25.     print(key, '--->', val)
27. print("*" * 100)
29. # 3.2 方式二
30. for key,val in dict1.items():
31.     print(key, '--->', val)

复制代码

互换变量值

使用拆包方式可以用于互换变量的值。

例
（1）有变量a、b，请完成变量之间值的互换；
（2）使用引入第三方变量的形式完成数值的互换；

1. # （1）有变量a、b，请完成变量之间值的交换；
2. a = 10
3. b = 20
5. # （2）使用引入第三方变量的形式完成数值的交换；
6. # 方案二
7. (b, a) = (a, b)
8. print(f"a = {a}, b = {b}")
10. # 方案一
11. c = a
12. a = b
13. b = c
14. print(f"a = {a}, b = {b}")
17. # （3）使用拆包方式完成数值交换。
18. """
19. 有一个整数列表, 按正序排列 list1 = [100, 20, 40, 50, 30, 35]
20.     循环1: i in [0, -2]
21.         循环2: [i+1, -1]
22.             if 列表[i]>列表[i+1]: 交换
23. """
24. list1 = [100, 20, 40, 50, 30, 35]
26. # 逆序
27. for i in range(0, len(list1)-1):
28.     for j in range(i+1, len(list1)):
29.         if list1[i]>list1[j]:
30.             list1[i], list1[j] = list1[j], list1[i] # 交换位置
31. print(list1)
34. # 正序
35. for i in range(0, len(list1)-1):
36.     for j in range(i+1, len(list1)):
37.         if list1[i]<list1[j]:
38.             list1[i], list1[j] = list1[j], list1[i] # 交换位置
39. print(list1)

复制代码

引用

注意：因为列表和字典是可变范例，以是会开发新空间，以是地点不相同

1. # 目标1: 引用
2. # 1.1 基本类型引用
3. a = 5;
4. b = 5;
5. print(id(a))
6. print(id(b))
7. print("-" * 50)
9. # 字符串
10. c = "abc"
11. d = "abc"
12. print(id(c))
13. print(id(d))
14. print("-" * 50)
15. # 1.2 复杂类型引用
16. # 1.2.1 列表(可变)
17. list1 = [1,3,5]
18. list2 = [1,3,5]
19. print(id(list1)) # 1979679672512
20. print(id(list2)) # 1979678989952
21. print("-" * 50)
23. # 1.2.2 元组(不可变)
24. t1 = (1,3,5)
25. t2 = (1,3,5)
26. print(id(t1))
27. print(id(t2))
28. print("-" * 50)
30. # 1.2.3 字典(可变)
31. dict1 = {"a":1, "b":2, "c":3, "d":4}
32. dict2 = {"a":1, "b":2, "c":3, "d":4}
33. print(id(dict1)) # 1565550724096
34. print(id(dict2)) # 1565550724160
35. print("-" * 50)
37. # 3 对比内容
38. # 3.1 基本类型
39. a = 5;
40. b = 5;
42. print(a == b)   # 内容: True
43. print(a is b)   # 地址: True
45. str1 = "aaa"
46. str2 = "aaa"
48. print(a == b)   # 内容: True
49. print(a is b)   # 地址: True
50. print("-" * 50)
52. # 3.2 复杂类型
53. # 3.2.1 列表(可变)
54. list1 = [1,3,5]
55. list2 = [1,3,5]
56. print(list1 == list2)  # 内容: True
57. print(list1 is list2)  # 地址: False
58. print("-" * 50)
60. # 3.2.2 元组(不可变)
61. t1 = (1,3,5)
62. t2 = (1,3,5)
64. print(t1 == t2)  # 内容: True
65. print(t1 is t2)  # 地址: True
66. print("-" * 50)
68. # 1.2.3 字典(可变)
69. dict1 = {"a":1, "b":2, "c":3, "d":4}
70. dict2 = {"a":1, "b":2, "c":3, "d":4}
72. print(dict1 == dict2)  # 内容: True
73. print(dict1 is dict2)  # 地址: False
74. print("-" * 50)

复制代码

lambda函数

定义匿名函数必要使用lambda关键字，可以创建小型匿名函数。
匿名函数表现没有名字的函数，这种函数得名于省略了用def关键字声明函数的标准步骤

   # 定义匿名函数语法：
  lambda 参数列表 : 表达式
  # 调用匿名函数语法：
  函数名 = lambda 参数列表 : 表达式
函数名([参数列表])
  例
（1）求解两个数之和；
（2）使用def定义函数，完成求和操纵；
（3）使用匿名函数简化函数求和操纵。

1. # 目标1: 获取两个数的和
2. # 方式一
3. def get_sum(a, b):
4.     return a + b
6. print(get_sum(2, 5))
8. # 方式二：lambda简化
9. get_sum_2 = lambda a, b : a + b
10. print(get_sum_2(6, 5))
14. # 目标2: 明确有两个参数, 由用户来确定计算的规则
15. def get_result(a, b, fn):
16.     return fn(a, b)
18. result1 = get_result(10, 5, lambda a, b : a * b)
19. print(result1)
21. result2 = get_result(10, 5, lambda a, b : a / b)
22. print(result2)
24. result3 = get_result(10, 5, lambda a, b : a + b)
25. print(result3)
27. result4 = get_result(10, 5, lambda a, b : a - b)
28. print(result4)

复制代码

lambda实例

1. # 1 无参数
2. # 1.1 不用lambda
3. def func1():
4.     return 21
6. print(func1) # 地址
7. print(func1()) # 内容
9. # 1.2 用lambda
10. func1_2 = lambda : 66
11. print(func1_2) # 地址
12. print(func1_2()) # 内容
14. # 2 带参数
15. # 2.1 不用lambda
16. def func2(a, b):
17.     return a * b
19. print(func2(10, 20))
21. # 2.2 用lambda
22. func2_2 = lambda a, b : a * b
23. print(func2_2(3, 60))
25. # 3 带默认参数的lambda表达式
26. # 3.1 不用lambda
27. def func3(a, b, c=100):
28.     return a+b+c
30. print(func3(1, 2))
31. print(func3(1, 2, 3))
33. # 3.2 用lambda
34. func3_2 = lambda a, b, c=100: a+b+c
35. print(func3_2(3, 2))
36. print(func3_2(3, 2, 20))
38. # 4 不定长参数：可变参数*args
39. # # 4.1 不用lambda
40. def func4(*args):
41.     return args
44. print(func4(10, 20, 30, 40))
45. print(type(func4(10, 20, 30, 40)))
47. # 4.2 用lambda
48. func4_2 = lambda *args : args
49. print(func4_2(66, 88, 99, 21))
50. print(type(func4_2(10, 20, 30, 40)))
52. # 5 不定长参数：可变参数**kwargs
53. # 5.1 不用lambda
54. def func5(**kwargs):
55.     return kwargs
57. print(func5(name="悟空", skill="七十二变", sex="男"))
59. # 5.2 用lambda
60. func5_2 = lambda **kwargs : kwargs
61. print(func5_2(name="八戒", skill="三十六变", sex="男"))
63. # 6 带if判断（三目运算符）的lambda表达式
64. # 6.1 不用lambda
65. def get_max(a, b):
66.     if a > b:
67.         return a
68.     else:
69.         return b
72. print(get_max(2, 5))
73. print(get_max(20, 5))
74. print(get_max(20, 50))
76. # 6.2 用lambda
77. get_max_2 = lambda a, b : a if a > b else b
78. print(get_max_2(120, 50))
79. print(get_max_2(120, 500))

复制代码

字典的lambda

1. student_list = [
2.     {"name":"悟空", "skill" : "火眼金睛", "wulizhi":90},
3.     {"name":"二郎神", "skill" : "放狗", "wulizhi":120},
4.     {"name":"哪吒", "skill" : "三头六臂", "wulizhi":80}
5. ]
7. student_list.sort(key=lambda x: x["name"]) # 根据名字排序
8. print(student_list)
10. student_list.sort(key=lambda x: x["wulizhi"]) # 根据武力值排序
11. print(student_list)
13. student_list.sort(key=lambda x: x["wulizhi"], reverse=True)  # 根据武力值逆序
14. print(student_list)

复制代码

推导式

共有三种推导：列表推导式，聚集推导式，字典推导式
列表推导式

   变量名 = [表达式 for 变量 in 列表]
变量名 = [表达式 for 变量 in 列表 if 条件]
变量名 = [表达式 for 变量 in 列表 for 变量 in 列表]
  创建一个0-9的列表

1. # 目标: 获取 0-9的列表
2. # 1 while
3. # 初始化计数器
4. i = 0
5. list1 = []
6. # 编写循环条件
7. while i <= 9:
8.     list1.append(i)
9.         # 更新计数器
10.     i += 1
11. print(list1)
13. # 2 for
14. list1 = []
15. # 编写for循环
16. for i in range(0, 10):
17.     list1.append(i)
18. print(list1)
20. # 3 列表表达式
21. list3 = [i for i in range(0, 10)]
22. print(list3)

复制代码

列表推导式+if条件判断

   变量 = [表达式 for 暂时变量 in 序列 if 条件判断]
  
  等价于
  
  for 暂时变量 in 序列:
    if 条件判断
  生成0-9之间的偶数序列

1. list3 = [i for i in range(10) if i % 2 == 0]
2. print(list3)

复制代码

for循环嵌套列表推导式

   for 暂时变量 in range(n):
    for 暂时变量 in range(n):
  
  等价于
  
  变量 = [表达式 for 暂时变量 in 序列 for 暂时变量 in 序列]
  创建列表 => [(1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]

1. # 不用 推导式
2. tuple_list = []
3. for i in range(1,3):
4.     for j in range(0,3):
5.         tuple_list.append((i, j))
7. print(tuple_list)
9. # 用 推导式
10. tuple_list_2 = [(i, j) for i in range(1,3) for j in range(0,3)]
11. print(tuple_list_2)

复制代码

字典推导式

   变量 = {key:value for key,value in 序列}
  例1：创建一个字典：字典key是1-5数字，value是这个数字的2次方。

1. dict1 = {i:i**2 for i in range(1,6)}
2. print(dict1)

复制代码

例2：把两个列表合并为一个字典

1. list1 = ['name', 'age', 'gender']
2. list2 = ['Tom', 20, 'male']
3. # 结果：person = {'name':'Tom', 'age':20, 'gender':'male'}
5. person = {list1[i]:list2[i] for i in range(len(list1))}
6. print(person)

复制代码

例3：提取字典中目标数据

1. counts = {'MBP': 268, 'HP': 125, 'DELL': 201, 'Lenovo': 199, 'ACER': 99}
3. # 需求：提取上述电脑数量大于等于200的字典数据
4. counts = {key:value for key, value in counts.items() if value >= 200}
5. print(counts)

复制代码

聚集推导式

聚集推导式跟列表推导式非常相似，唯一区别在于用 { } 代替 [ ]。
聚集最大的特点就是去重
创建一个聚集，数据为下方列表的2次方。

1. list1 = [1, 1, 2]
2. set1 = {i**2 for i in list1}
3. print(set1)

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。