Python-VBA函数之旅-sorted函数

目录

一、sorted函数的常见应用场景

二、sorted函数使用注意事项

三、如何用好sorted函数？

1、sorted函数：

1-1、Python：

1-2、VBA：

2、推荐阅读：

个人主页： https://blog.csdn.net/ygb_1024?spm=1010.2135.3001.5421

 

一、sorted函数的常见应用场景

        sorted函数在Python中非常有用，因为它允许你对各种数据结构进行排序，常见的应用场景有：

1、基本列表排序：当你有一个列表并希望根据列表中的元素值进行排序时，你可以使用sorted()函数。例如，你可能有一个包含学生分数的列表，你想知道哪个学生的分数最高或最低。

2、元组列表排序：你可以对包含元组的列表进行排序，根据元组中的某个元素值，这在处理具有多个属性的数据记录时非常有用。

3、字典列表排序：如果你有一个包含字典的列表，并希望根据字典中的某个值进行排序，你可以使用sorted()函数和lambda函数作为key参数。例如，你可能有一个包含员工信息的字典列表，并希望根据员工的年龄或薪水进行排序。

4、字符串列表排序：如果你有一个包含字符串的列表，并希望按照字母顺序或字符串长度进行排序，你可以使用sorted()函数并传递适当的key参数。例如，你可能有一个包含文件名的列表，并希望按文件名长度进行排序。

5、自定义对象排序：如果你有一个自定义对象的列表，并希望根据对象的某个属性进行排序，你可以使用sorted()函数和类的属性作为key参数，这要求你的对象是可比较的，或者你可以提供一个比较函数或方法。

6、复杂对象排序：当需要根据对象的多个属性进行排序时，可以通过在key参数中提供一个函数来实现，这个函数接受一个对象作为输入，并返回一个用于排序的值(可以是元组，以便根据多个属性排序)。

7、处理文件和数据集：在处理大量数据时，你可能需要将数据按照特定顺序进行排序，以便进行进一步的分析或可视化，sorted()函数可以用于此目的。

8、算法和数据结构：在编写算法或实现数据结构(如排序算法、搜索算法、图算法等)时，sorted()函数可能是一个有用的工具，用于验证你的实现是否正确。

9、与生成器结合使用：sorted()函数可以接受任何可迭代对象作为输入，包括生成器，这允许你在不需要将整个数据集加载到内存中的情况下进行排序。

10、排序后切片操作：结合sorted()函数和列表切片，可以很容易地获取排序后的前N个元素。

11、与列表推导式结合使用：你可以将sorted()函数与列表推导式结合使用，以创建新的已排序列表，同时根据某个条件筛选或转换元素。

二、sorted函数使用注意事项

        在Python中，sorted()函数是一个非常有用的内置函数，用于对可迭代对象(如列表、元组、字典等)进行排序。相关注意事项如下：

1、原始数据不会被修改：sorted()函数返回一个新的已排序列表，而原始的可迭代对象不会被修改。

2、排序的稳定性：Python的sorted()函数在排序时保证是稳定的，即具有相同值的元素在排序后的顺序与它们在原始列表中的顺序相同。

3、排序关键字：sorted()函数允许你通过`key`参数指定一个函数，该函数将在比较元素之前应用于每个元素，这对于非数字类型(如字符串、元组、字典等)的排序特别有用。

4、排序顺序：默认情况下，sorted()函数按升序排序。你可以通过reverse=True参数将其更改为降序排序。

5、排序对象：虽然sorted()函数主要用于列表，但它也可以用于其他可迭代对象，如元组、集合和字典(当用于字典时，默认对键进行排序)。

6、性能：对于大型数据集，sorted()函数的性能可能是一个问题，在这种情况下，你可能需要考虑使用更高效的排序算法或数据结构，或者考虑是否可以在数据收集阶段就进行排序。

7、数据类型：sorted()函数可以对多种数据类型进行排序，但你需要确保你的比较操作是有意义的。例如，对于不同类型的对象(如字符串和数字)，直接比较可能会导致TypeError异常，在这种情况下，你可能需要在应用sorted()之前对数据进行转换或清洗。

三、如何用好sorted函数？

        要使用好Python中的sorted()函数，你需遵循以下建议：

1、理解排序的稳定性：当排序的元素中有重复值时，sorted()函数会保持它们的原始顺序(即稳定的排序)，这在进行多键排序时尤其有用。

2、选择合适的排序键：通过key参数，你可以为sorted()函数提供一个函数，该函数将应用于输入可迭代对象的每个元素，并决定排序的依据。例如，你可以根据字符串的长度、列表中的第二个元素或其他任何复杂的条件进行排序。

3、使用lambda表达式：key参数经常与lambda表达式一起使用，以简洁地定义排序键，Lambda表达式允许你快速定义简单的匿名函数。

4、考虑性能：对于大型数据集，排序可能会很耗时，如果可能的话，尝试在收集数据时就保持有序，或者在需要之前对数据进行预处理以减少排序的开销。

5、使用reverse参数：如果你想要以降序而不是默认的升序进行排序，可以设置reverse=True。

6、对字典排序：你可以使用sorted()函数对字典的键或值进行排序：默认情况下，sorted(dict)会返回按键排序的键的列表；要按值排序，可以传入dict.items()并使用key参数来指定值。

7、排序自定义对象：如果你的可迭代对象包含自定义类的实例，并且你想要根据这些实例的某个属性进行排序，你可以提供一个key函数来访问该属性。

8、避免不必要的排序：在某些情况下，你可能不需要对整个数据集进行排序。例如，如果你只需要找到最大或最小的元素，可以使用max()或min()函数，它们通常比排序整个列表更快。

9、使用sorted()函数而不是列表的`.sort()`方法：sorted()函数返回一个新的已排序列表，而列表的`.sort()`方法会修改原始列表；如果你不希望修改原始数据，或者你想要保留原始数据的多个排序版本，那么使用sorted()函数会更好。

10、利用operator模块：对于简单的排序键(如按数字大小或字符串字母顺序)，你可以使用operator模块中的函数作为key参数，而不是定义自己的lambda表达式，如operator.itemgetter()函数可以用于根据元组的特定项进行排序。

1、sorted函数：
1-1、Python：
  1. # 1.函数：sorted
  2. # 2.功能：用于对可迭代对象进行排序
  3. # 3.语法：sorted(iterable[, key=None, reverse=False])
  4. # 4.参数：
  5. # 4-1、iterable(必须)：表示可迭代对象，如列表、字符串、字典等
  6. # 4-2、key(可选)：表示一个函数或方法，用来指定排序规则；默认key=None，表示直接比较元素进行排序
  7. # 4-3、reverse(可选)：一个布尔值，即排序规则，默认reverse=False，表示升序排列；若设置reverse=True，则表示降序排列
  8. # 5.返回值：返回重新排序的列表
  9. # 6.说明：列表对象的.sort()方法和内置sorted()函数的作用基本相同，差异如下：
  10. # 6-1、列表对象的.sort()方法：直接修改原始列表，生成新列表，影响原始列表
  11. # 6-2、内置sorted()函数：会建立一个原始列表的副本，该副本为排序后的列表，不影响原始列表
  12. # 7.示例：
  13. # 用dir()函数获取该函数内置的属性和方法
  14. print(dir(sorted))
  15. # ['__call__', '__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__',
  16. # '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__name__',
  17. # '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__self__', '__setattr__', '__sizeof__',
  18. # '__str__', '__subclasshook__', '__text_signature__']
  19.  
  20. # 用help()函数获取该函数的文档信息
  21. help(sorted)
  22.  
  23. # 应用一：基本列表排序
  24. # 示例1: 对整数列表进行排序
  25. # 创建一个整数列表
  26. numbers = [3, 6, 10, 8, 10, 24, 5, 11]
  27. # 使用sorted()函数进行排序
  28. sorted_numbers = sorted(numbers)
  29. # 打印排序后的列表
  30. print(sorted_numbers)
  31. # [3, 5, 6, 8, 10, 10, 11, 24]
  32.  
  33. # 示例2: 对字符串列表进行排序
  34. # 创建一个字符串列表
  35. words = ['Myelsa', 'Jimmy', 'Lucy', 'Bruce']
  36. # 使用sorted()函数进行排序
  37. sorted_words = sorted(words, key=str.isupper)
  38. # 打印排序后的列表
  39. print(sorted_words)
  40. # ['Myelsa', 'Jimmy', 'Lucy', 'Bruce']
  41.  
  42. # 示例3: 使用key参数按字符串长度排序
  43. # 创建一个字符串列表
  44. words = ['Myelsa', 'Jimmy', 'Lucy', 'Bruce']
  45. # 使用sorted()函数和key参数，按字符串长度进行排序
  46. sorted_words_by_length = sorted(words, key=len)
  47. # 打印排序后的列表
  48. print(sorted_words_by_length)
  49. # ['Lucy', 'Jimmy', 'Bruce', 'Myelsa']
  50.  
  51. # 示例4: 对字典列表按某个键值排序
  52. # 创建一个包含字典的列表
  53. students = [{'name': 'Myelsa', 'age': 18}, {'name': 'Bruce', 'age': 6}, {'name': 'Jimmy', 'age': 15}]
  54. # 使用sorted() 函数key参数，按'age'键值进行排序
  55. sorted_students_by_age = sorted(students, key=lambda s: s['age'])
  56. # 打印排序后的列表
  57. print(sorted_students_by_age)
  58. # [{'name': 'Bruce', 'age': 6}, {'name': 'Jimmy', 'age': 15}, {'name': 'Myelsa', 'age': 18}]
  59.  
  60. # 示例5: 对字典列表按多个键值排序(先按年龄，再按名字)
  61. # 创建一个包含字典的列表
  62. students = [{'name': 'Myelsa', 'age': 18}, {'name': 'Jimmy', 'age': 15}, {'name': 'Bruce', 'age': 6}]
  63. # 使用sorted()函数和key参数，先按'age'键值进行排序，然后按'name'键值进行排序
  64. sorted_students_by_age_and_name = sorted(students, key=lambda s: (s['age'], s['name']))
  65. # 打印排序后的列表
  66. print(sorted_students_by_age_and_name)
  67. # [{'name': 'Bruce', 'age': 6}, {'name': 'Jimmy', 'age': 15}, {'name': 'Myelsa', 'age': 18}]
  68.  
  69. # 示例6: 使用reverse参数进行降序排序
  70. # 创建一个整数列表
  71. numbers = [3, 6, 10, 8, 10, 24, 5, 11]
  72. # 使用sorted()函数和reverse参数进行降序排序
  73. sorted_numbers_desc = sorted(numbers, reverse=True)
  74. # 打印排序后的列表
  75. print(sorted_numbers_desc)
  76. # [24, 11, 10, 10, 8, 6, 5, 3]
  77.  
  78. # 应用二：元组列表排序
  79. # 示例1: 对元组列表按照第一个元素排序
  80. # 创建一个包含元组的列表
  81. tuples_list = [(3, 'apple'), (1, 'banana'), (4, 'cherry'), (1, 'date')]
  82. # 使用sorted()函数按照元组的第一个元素进行排序
  83. sorted_tuples = sorted(tuples_list, key=lambda x: x[0])
  84. # 打印排序后的列表
  85. print(sorted_tuples)
  86. # [(1, 'banana'), (1, 'date'), (3, 'apple'), (4, 'cherry')]
  87.  
  88. # 示例2: 对元组列表按照第二个元素(字符串)进行排序
  89. # 创建一个包含元组的列表
  90. tuples_list = [(3, 'apple'), (1, 'banana'), (4, 'cherry'), (2, 'apple')]
  91. # 使用sorted()函数按照元组的第二个元素(字符串)进行排序
  92. sorted_tuples = sorted(tuples_list, key=lambda x: x[1])
  93. # 打印排序后的列表
  94. print(sorted_tuples)
  95. # [(3, 'apple'), (2, 'apple'), (1, 'banana'), (4, 'cherry')]
  96.  
  97. # 示例3: 对元组列表先按第一个元素(降序)，然后按第二个元素(升序)进行排序
  98. # 创建一个包含元组的列表
  99. tuples_list = [(3, 'apple'), (1, 'banana'), (3, 'cherry'), (2, 'apple')]
  100. # 使用sorted()函数和key参数，先按元组的第一个元素(降序)，然后按第二个元素(升序)进行排序
  101. sorted_tuples = sorted(tuples_list, key=lambda x: (-x[0], x[1]))
  102. # 打印排序后的列表
  103. print(sorted_tuples)
  104. # [(3, 'apple'), (3, 'cherry'), (2, 'apple'), (1, 'banana')]
  105.  
  106. # 应用三：字典列表排序
  107. # 示例1: 对字典列表按照某个键的值进行升序排序
  108. # 创建一个包含字典的列表
  109. dict_list = [
  110.     {'name': 'Myelsa', 'age': 18},
  111.     {'name': 'Bruce', 'age': 6},
  112.     {'name': 'Jimmy', 'age': 15},
  113. ]
  114. # 使用sorted()函数和key参数，按照'age'键的值进行升序排序
  115. sorted_dict_list = sorted(dict_list, key=lambda item: item['age'])
  116. # 打印排序后的列表
  117. print(sorted_dict_list)
  118. # [{'name': 'Bruce', 'age': 6}, {'name': 'Jimmy', 'age': 15}, {'name': 'Myelsa', 'age': 18}]
  119.  
  120. # 示例2: 对字典列表按照某个键的值进行降序排序
  121. # 创建一个包含字典的列表
  122. dict_list = [
  123.     {'name': 'Myelsa', 'age': 18},
  124.     {'name': 'Bruce', 'age': 6},
  125.     {'name': 'Jimmy', 'age': 15},
  126. ]
  127. # 使用sorted()函数和key参数，以及reverse参数，按照'age'键的值进行降序排序
  128. sorted_dict_list_desc = sorted(dict_list, key=lambda item: item['age'], reverse=True)
  129. # 打印排序后的列表
  130. print(sorted_dict_list_desc)
  131. # [{'name': 'Myelsa', 'age': 18}, {'name': 'Jimmy', 'age': 15}, {'name': 'Bruce', 'age': 6}]
  132.  
  133. # 示例3: 对字典列表按照多个键进行排序(先按一个键升序，后按另一个键降序)
  134. # 创建一个包含字典的列表
  135. dict_list = [
  136.     {'name': 'Myelsa', 'age': 18},
  137.     {'name': 'Bruce', 'age': 6},
  138.     {'name': 'Jimmy', 'age': 15},
  139. ]
  140. # 假设我们想要先按'age'升序排序，然后按'name'降序排序
  141. sorted_dict_list_multi = sorted(dict_list, key=lambda item: (
  142. item['age'], -ord(item['name'][0])))  # 使用ord()将字符串的第一个字符转换为ASCII值以便排序
  143. # 打印排序后的列表
  144. print(sorted_dict_list_multi)
  145. # [{'name': 'Bruce', 'age': 6}, {'name': 'Jimmy', 'age': 15}, {'name': 'Myelsa', 'age': 18}]
  146.  
  147. # 应用四：字符串列表排序
  148. # 示例1: 对字符串列表进行升序排序
  149. # 创建一个字符串列表
  150. string_list = ['banana', 'apple', 'cherry', 'orange']
  151. # 使用sorted()函数进行升序排序
  152. sorted_strings = sorted(string_list)
  153. # 打印排序后的列表
  154. print(sorted_strings)
  155. # ['apple', 'banana', 'cherry', 'orange']
  156.  
  157. # 示例2: 对字符串列表进行降序排序
  158. # 创建一个字符串列表
  159. string_list = ['banana', 'apple', 'cherry', 'orange']
  160. # 使用sorted()函数和 reverse 参数进行降序排序
  161. sorted_strings_desc = sorted(string_list, reverse=True)
  162. # 打印排序后的列表
  163. print(sorted_strings_desc)
  164. # ['orange', 'cherry', 'banana', 'apple']
  165.  
  166. # 示例3: 对字符串列表按字符串长度进行排序
  167. # 创建一个字符串列表
  168. string_list = ['banana', 'apple', 'cherry', 'orange']
  169. # 使用sorted()函数和key参数，按字符串长度进行排序
  170. sorted_strings_by_length = sorted(string_list, key=len)
  171. # 打印排序后的列表
  172. print(sorted_strings_by_length)
  173. # ['apple', 'banana', 'cherry', 'orange']
  174.  
  175. # 示例4: 对字符串列表按字符串中某个字符的位置进行排序
  176. # 创建一个字符串列表
  177. string_list = ['banana', 'apple', 'cherry', 'orange']
  178. # 假设我们想要根据字符串中'a'的第一个出现位置进行排序
  179. # 使用sorted()函数和自定义的key函数
  180. def find_first_a(s):
  181.     return s.find('a') if 'a' in s else float('inf')  # 如果'a'不在字符串中，返回无穷大
  182. sorted_strings_by_a_position = sorted(string_list, key=find_first_a)
  183. # 打印排序后的列表
  184. print(sorted_strings_by_a_position)  # 输出将会基于'a'在每个字符串中的第一个出现位置进行排序
  185. # ['apple', 'banana', 'orange', 'cherry']
  186.  
  187. # 应用五：自定义对象排序
  188. class Person:
  189.     def __init__(self, name, age):
  190.         self.name = name
  191.         self.age = age
  192.     def __repr__(self):
  193.         return f'Person({self.name}, {self.age})'
  194. # 创建一个Person对象的列表
  195. people = [
  196.     Person('Myelsa', 18),
  197.     Person('Bruce', 6),
  198.     Person('Jimmy', 15),
  199. ]
  200. # 使用sorted()函数和lambda表达式作为key函数，按age属性进行升序排序
  201. sorted_people_by_age = sorted(people, key=lambda person: person.age)
  202. # 打印排序后的列表
  203. print(sorted_people_by_age)
  204. # 使用sorted()函数和reverse参数，按age属性进行降序排序
  205. sorted_people_by_age_desc = sorted(people, key=lambda person: person.age, reverse=True)
  206. # 打印排序后的列表
  207. print(sorted_people_by_age_desc)
  208. # 如果你想先按age升序排序，然后按name升序排序(在age相同的情况下)
  209. sorted_people_multi = sorted(people, key=lambda person: (person.age, person.name))
  210. # 打印排序后的列表
  211. print(sorted_people_multi)
  212. # [Person(Bruce, 6), Person(Jimmy, 15), Person(Myelsa, 18)]
  213. # [Person(Myelsa, 18), Person(Jimmy, 15), Person(Bruce, 6)]
  214. # [Person(Bruce, 6), Person(Jimmy, 15), Person(Myelsa, 18)]
  215.  
  216. # 应用六：复杂对象排序
  217. class Employee:
  218.     def __init__(self, name, department, salary):
  219.         self.name = name
  220.         self.department = department
  221.         self.salary = salary
  222.     def __repr__(self):
  223.         return f'Employee({self.name}, {self.department}, {self.salary})'
  224. # 创建一个 Employee 对象的列表
  225. employees = [
  226.     Employee('Lucy', 'HR', 50000),
  227.     Employee('Bruce', 'Engineering', 60000),
  228.     Employee('Jimmy', 'Engineering', 55000),
  229.     Employee('David', 'HR', 52000),
  230. ]
  231. # 使用sorted()函数和lambda表达式作为key函数，首先按部门排序(字母顺序)，然后按薪水降序排序
  232. sorted_employees = sorted(employees, key=lambda emp: (emp.department, -emp.salary))
  233. # 打印排序后的列表
  234. print(sorted_employees)
  235. # 如果你想在薪水相同时再按名字排序
  236. sorted_employees_full = sorted(employees, key=lambda emp: (emp.department, -emp.salary, emp.name))
  237. # 打印排序后的列表
  238. print(sorted_employees_full)
  239. # [Employee(Bruce, Engineering, 60000), Employee(Jimmy, Engineering, 55000), Employee(David, HR, 52000), Employee(Lucy, HR, 50000)]
  240. # [Employee(Bruce, Engineering, 60000), Employee(Jimmy, Engineering, 55000), Employee(David, HR, 52000), Employee(Lucy, HR, 50000)]
  241.  
  242. # 应用七：处理文件和数据集
  243. # 读取文件并分割每行的数据
  244. with open('test.txt', 'r') as file:
  245.     data = [line.strip().split() for line in file]
  246. # 将数据转换为可以排序的形式(例如，将年龄转换为整数)
  247. data_with_ages = [(name, int(age)) for name, age in data]
  248. # 使用sorted()函数对数据进行排序(按年龄升序)
  249. sorted_data = sorted(data_with_ages, key=lambda x: x[1])
  250. # 如果需要，你可以将排序后的数据转换回原始格式(名字和年龄作为字符串)
  251. sorted_data_str = [(name, str(age)) for name, age in sorted_data]
  252. # 打印排序后的数据
  253. for name, age in sorted_data_str:
  254.     print(f"{name} {age}")
  255. # apple 24
  256. # banana 32
  257. # cherry 46
  258. # orange 58
  259.  
  260. # 应用八：算法和数据结构
  261. # 假设我们有两个已排序的列表
  262. list1 = [1, 3, 5, 7]
  263. list2 = [2, 4, 6, 8]
  264. # 使用sorted()函数和列表推导式来合并并排序两个列表
  265. # 注意：这不是最高效的方法，因为它会重新排序合并后的列表
  266. # 通常我们会使用双指针法或heapq.merge()来合并已排序列表
  267. merged_list = sorted(list1 + list2)
  268. print(merged_list)
  269. # 更高效的方法(不使用sorted())
  270. def merge_sorted_lists(list1, list2):
  271.     merged = []
  272.     i = j = 0
  273.     while i < len(list1) and j < len(list2):
  274.         if list1[i] < list2[j]:
  275.             merged.append(list1[i])
  276.             i += 1
  277.         else:
  278.             merged.append(list2[j])
  279.             j += 1
  280.     # 添加剩余的元素（如果有的话）
  281.     merged.extend(list1[i:])
  282.     merged.extend(list2[j:])
  283.     return merged
  284. # 使用更高效的方法合并列表
  285. efficient_merged_list = merge_sorted_lists(list1, list2)
  286. print(efficient_merged_list)
  287. # [1, 2, 3, 4, 5, 6, 7, 8]
  288. # [1, 2, 3, 4, 5, 6, 7, 8]
  289.  
  290. # 应用九：与生成器结合使用
  291. # 定义一个生成器，它生成从1到10的平方数
  292. def squares_generator(n):
  293.     for i in range(1, n + 1):
  294.         yield i ** 2
  295. # 使用sorted()函数与生成器结合，按从小到大的顺序对平方数进行排序
  296. sorted_squares = sorted(squares_generator(10))
  297. # 打印排序后的平方数
  298. print(sorted_squares)
  299. # 另一个示例：使用sorted()和lambda表达式与生成器结合，按从大到小的顺序对平方数进行排序
  300. sorted_squares_desc = sorted(squares_generator(10), reverse=True)
  301. # 打印按降序排序后的平方数
  302. print(sorted_squares_desc)
  303. # 如果你想要根据某种复杂的逻辑进行排序，你可以使用lambda表达式
  304. # 假设我们想要根据平方数的奇偶性进行排序，奇数在前，偶数在后
  305. sorted_squares_odd_even = sorted(squares_generator(10), key=lambda x: (x % 2, x))
  306. # 打印按奇偶性排序后的平方数
  307. print(sorted_squares_odd_even)
  308. # 注意：由于奇数和偶数各自内部还是按数值大小排序的，所以结果可能因Python版本或实现细节略有不同
  309. # [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
  310. # [100, 81, 64, 49, 36, 25, 16, 9, 4, 1]
  311. # [4, 16, 36, 64, 100, 1, 9, 25, 49, 81]
  312.  
  313. # 应用十：排序后切片操作
  314. # 假设我们有一个包含整数的列表
  315. numbers = [3, 6, 10, 8, 10, 24, 5, 11]
  316. # 使用sorted()函数对列表进行排序
  317. sorted_numbers = sorted(numbers)
  318. # 打印排序后的整个列表
  319. print("Sorted numbers:", sorted_numbers)
  320. # 使用切片操作获取排序后列表的前三个元素
  321. first_three = sorted_numbers[:3]
  322. # 打印切片后的列表
  323. print("First three elements:", first_three)
  324. # 使用切片操作获取排序后列表的中间三个元素(如果列表长度大于或等于5)
  325. middle_three = sorted_numbers[1:4]  # 注意：切片操作是左闭右开的
  326. # 打印切片后的列表
  327. print("Middle three elements:", middle_three)
  328. # 使用切片操作获取排序后列表的最后两个元素
  329. last_two = sorted_numbers[-2:]
  330. # 打印切片后的列表
  331. print("Last two elements:", last_two)
  332. # 注意：切片操作不会修改原始列表，而是返回一个新的列表切片
  333. print("Original list is unchanged:", numbers)
  334. # Sorted numbers: [3, 5, 6, 8, 10, 10, 11, 24]
  335. # First three elements: [3, 5, 6]
  336. # Middle three elements: [5, 6, 8]
  337. # Last two elements: [11, 24]
  338. # Original list is unchanged: [3, 6, 10, 8, 10, 24, 5, 11]
  339.  
  340. # 应用十一：与列表推导式结合使用
  341. # 示例1：将字符串列表转换为整数列表并排序
  342. # 假设我们有一个包含数字的字符串列表
  343. string_numbers = ['3', '6', '10', '8', '10', '24', '5', '11']
  344. # 使用列表推导式将字符串转换为整数，并使用sorted()排序
  345. sorted_int_numbers = sorted(int(num) for num in string_numbers)
  346. print(sorted_int_numbers)
  347. # [3, 5, 6, 8, 10, 10, 11, 24]
  348.  
  349. # 示例2：根据字典列表中某个键的值进行排序
  350. # 假设我们有一个字典列表，每个字典代表一个学生，包含姓名和分数
  351. students = [{'name': 'Myelsa', 'score': 98},
  352.             {'name': 'Bruce', 'score': 85},
  353.             {'name': 'Jimmy', 'score': 95}]
  354. # 使用列表推导式和sorted()按分数排序学生(降序)
  355. sorted_students_desc = sorted(students, key=lambda s: s['score'], reverse=True)
  356. for student in sorted_students_desc:
  357.     print(student['name'], student['score'])
  358. # Myelsa 98
  359. # Jimmy 95
  360. # Bruce 85
  361.  
  362. # 示例3：根据元组列表中元组的多个元素进行排序
  363. # 假设我们有一个元组列表，每个元组包含两个数字
  364. tuples_list = [(3, 6), (10, 8), (10, 24), (5, 11)]
  365. # 使用列表推导式和sorted()先按第一个元素排序，然后按第二个元素排序
  366. sorted_tuples = sorted(tuples_list, key=lambda t: (t[0], t[1]))
  367. print(sorted_tuples)
  368. # [(3, 6), (5, 11), (10, 8), (10, 24)]
1-2、VBA：
略，待后补。
2、推荐阅读：

2-1、Python-VBA函数之旅-round()函数

Python算法之旅：Algorithm

Python函数之旅：Functions

个人主页： https://blog.csdn.net/ygb_1024?spm=1010.2135.3001.5421
文章知识点与官方知识档案匹配，可进一步学习相关知识
算法技能树首页概览61139 人正在系统学习中
遨游码海，我心飞扬
微信名片
注：本文转载自blog.csdn.net的神奇夜光杯的文章"https://myelsa1024.blog.csdn.net/article/details/138671451"。版权归原作者所有，此博客不拥有其著作权，亦不承担相应法律责任。如有侵权，请联系我们删除。
复制链接
相关推荐
发表评论

评论记录：

未查询到任何数据！