Python3 小技巧—— sorted(t, key = lambda _: _[0])用法

最新推荐文章于 2025-07-03 09:01:19 发布
最新推荐文章于 2025-07-03 09:01:19 发布
阅读量1.6w 收藏 54
点赞数 24
CC 4.0 BY-SA版权
分类专栏： 软件 # Python 文章标签： python sorted 匿名函数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_24546137/article/details/86431365
本文通过《Python编程从入门到实践》一书，详细介绍了如何使用sorted()函数和lambda表达式对元组列表进行排序，展示了根据不同字段索引进行排序的具体应用。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

今天在看 Eric Matthes 的《Python编程从入门到实践》中看到这句，代码演示如下：

>>>a = ([1, 4, 3], [3, 2, 5], [5, 1, 2], [4, 3, 1], [2, 5, 3])
>>>sorted(a, key=lambda _: _[0])
[[1, 4, 3], [2, 5, 3], [3, 2, 5], [4, 3, 1], [5, 1, 2]]
>>>sorted(a, key=lambda _: _[1])
[[5, 1, 2], [3, 2, 5], [4, 3, 1], [1, 4, 3], [2, 5, 3]]
>>>sorted(a, key=lambda _: _[2])
[[4, 3, 1], [5, 1, 2], [1, 4, 3], [2, 5, 3], [3, 2, 5]]

sorted() 函数对所有可迭代的对象进行排序操作，key 是用来进行比较的元素。书写方式如下：

key=lambda 元素: 元素[字段索引]

lambda 用于匿名函数，可以免去命名函数的麻烦，上面的代码相当于与：

def fun(元素):
	return 元素[字段索引]
key = fun(元素)

sorted 函数按照字段索引进行排序。

Python-3.12.0文档解读-内置函数sorted()详细说明+记忆策略+常用场景+巧妙用法+综合技巧
weixin_44915521的博客
06-01 1220
可以通过 sorted() 函数和自定义的 key 函数对自定义对象列表进行排序。# 定义一个自定义类# 创建一个 Person 对象的列表# 使用 sorted() 对 Person 对象列表按年龄进行排序# 输出排序后的 Person 对象列表print(sorted_people) # 输出: [Jane (22), John (25), Dave (30)]可以通过自定义的排序顺序来对数据进行排序，例如按特定规则对字符串排序。# 自定义的排序顺序# 原始列表包含不同优先级的字符串。
Python3排序sorted(key=lambda)
zying的博客
09-07 9359
使用python对列表(list)进行排序，用函数sorted的具体方法：1.2.假如a是一个由元组构成的列表，我们需要用到参数key，也就是关键词，看下面这句命令，lambda是一个隐函数，是固定写法，不要写成别的单词；x表示列表中的一个元素，在这里，表示一个元组，x只是临时起的一个名字，你可以使用任意的名字；x[0]表示元组里的第一个元素，当然第二个元素就是x[1]；所以这句命令的意思就是按照...
python sort和sorted函数
weixin_33794672的博客
08-13 1463
sort 与 sorted 区别： sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。 list 的 sort 方法返回的是对已经存在的列表进行操作，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。 sorted 语法： sorted(iterable[, cmp[, key[, reverse]...
Python中的sort方法、sorted函数与lambda表达式
matlabxiao1的博客
07-03 1391
Python中的排序方法总结： sort()方法：原地修改列表，返回None，支持key和reverse参数。key参数用于自定义排序逻辑（如按长度、属性等），reverse控制升降序。 sorted()函数：适用于任何可迭代对象，返回新列表，不修改原数据。功能与sort()类似，但应用更广泛。 lambda函数：常用于排序场景，如sorted(items, key=lambda x: x[1])实现按元组第二元素排序，支持多级排序（返回排序键元组）。
Python 函数 sort()，sorted() 之区别及 key=lambda x:x[] 之理解
iprobobo的博客
01-28 3万+
数据排序
Python3 Sorted排序（key=lambda）
dream_coke的博客
07-25 3039
sorted(iterable[, key][, reverse]) 从iterable中的项目返回新的排序列表。 有两个可选参数，必须指定为关键字参数。 key指定一个参数的函数，用于从每个列表元素中提取比较键：key=str.lower。默认值为None（直接比较元素）。 reverse是一个布尔值。如果设置为True，那么列表元素将按照每个比较反转进行排序。 示例：创...
python3排序 sorted(key=lambda)
热门推荐
木子木泗的博客
03-29 9万+
　　当待排序列表的元素由多字段构成时，我们可以通过sorted(iterable，key，reverse)的参数key来制定我们根据那个字段对列表元素进行排序。 　　key=lambda 元素: 元素[字段索引] 　　例如：想对元素第二个字段排序，则 　　key=lambda y: y[1] 备注：这里y可以是任意字母，等同key=lambda x: x[1] 看...
import sensor import image import lcd import time import sys # 初始化摄像头 sensor.reset() sensor.set_pixformat(sensor.RGB565) sensor.set_framesize(sensor.QVGA) sensor.skip_frames(time=2000) # 初始化LCD（如果有） lcd.init() # 颜色阈值，用于二值化（这里假设矩形是深色，背景是浅色，或者相反，需要根据实际情况调整） gray_threshold = (0, 100) # 示例阈值，需要调整 while True: img = sensor.snapshot() # 转换为灰度图 img_gray = img.to_grayscale() # 二值化 # 注意：在新版固件中，binary方法返回一个新的二值图像对象；在旧版固件中，可能是原地操作并返回None img_bin = img_gray.binary([gray_threshold]) # 如果二值化后得到的是None（旧版固件可能原地操作），则使用img_gray作为二值图像 if img_bin is None: img_bin = img_gray # 旧版固件中，二值化操作已经作用在img_gray上 # 尝试两种方式查找轮廓 try: # 新版固件：使用二值图像调用find_contours contours = img_bin.find_contours(threshold=150, roi=(10,10,img.width()-20, img.height()-20)) except AttributeError: # 旧版固件：使用image.find_contours contours = image.find_contours(thresholds=[gray_threshold], roi=(10,10,img.width()-20,img.height()-20)) rectangles = [] for contour in contours: # 计算轮廓面积 area = contour.area() if area < 1000: # 忽略太小的轮廓 continue # 计算轮廓的矩形边界 rect = contour.min_rect() # 获取矩形的四个顶点 points = rect.corners() # 将四个点转换成元组列表 point_list = [(p[0], p[1]) for p in points] # 排序四个点：按照y坐标从小到大，然后对前两个点按x从小到大（左上、右上），后两个点按x从小到大（左下、右下） point_list.sort(key=lambda p: p[1]) top_points = sorted(point_list[:2], key=lambda p: p[0]) bottom_points = sorted(point_list[2:], key=lambda p: p[0]) sorted_points = top_points + bottom_points # 顺序：左上，右上，左下，右下 rectangles.append(sorted_points) # 如果检测到至少一个矩形 if rectangles: # 取第一个矩形 rect_pts = rectangles[0] # 建立坐标系：以左上角为原点(0,0) origin = rect_pts[0] # 左上角 # 计算矩形的宽和高（取右上角x-左上角x，左下角y-左上角y） width = rect_pts[1][0] - rect_pts[0][0] height = rect_pts[2][1] - rect_pts[0][1] # 选择两个点：这里选择左上角和右下角 point1 = rect_pts[0] # 左上角 point2 = rect_pts[3] # 右下角 # 在新建坐标系下的坐标： # 左上角：(0,0) # 右下角：(width, height) # 注意：实际中，由于透视变换，矩形的边可能不水平和垂直，这里假设矩形已经矫正（或者近似） # 在图像上标记点 img.draw_circle(int(point1[0]), int(point1[1]), 5, color=(255,0,0), thickness=2) img.draw_circle(int(point2[0]), int(point2[1]), 5, color=(0,255,0), thickness=2) # 输出坐标 print("Point1 (top-left): (0, 0)") print("Point2 (bottom-right): ({}, {})".format(width, height)) # 显示图像 lcd.display(img) time.sleep_ms(100) 这个代码中显示AttributeError: &#39;module&#39; object has no attribute &#39;find_contours&#39;这个报错，怎么修改
最新发布
07-17
- 确保图像已经二值化（使用binary方法）。 - 确保调用方法的对象是二值图像（或者灰度图像经过二值化处理）。 - 检查OpenMV固件版本，并查看对应版本的文档。 相关问题： 1. 在OpenMV中如何调整二值化阈值？ ...
import open3d as o3d import numpy as np import os def read_pointcloud(file_path): """读取点云文件""" try: pcd = o3d.io.read_point_cloud(file_path) print(f"成功读取点云: {file_path}") print(f"点云点数: {len(pcd.points)}") return pcd except Exception as e: print(f"读取点云失败: {e}") return None def get_pointcloud_bounds(pcd): """获取点云各轴的范围""" points = np.asarray(pcd.points) x_min, y_min, z_min = np.min(points, axis=0) x_max, y_max, z_max = np.max(points, axis=0) return { &#39;x&#39;: (x_min, x_max), &#39;y&#39;: (y_min, y_max), &#39;z&#39;: (z_min, z_max) } def segment_by_height(pcd, y_interval=0.1): """ 按高度(Y轴)分割点云 Args: pcd: 点云对象 y_interval: 高度区间大小(米) Returns: 分层结果字典: {高度下限: 点云对象} """ points = np.asarray(pcd.points) y_min, y_max = np.min(points[:, 1]), np.max(points[:, 1]) # 计算层数 num_layers = int(np.ceil((y_max - y_min) / y_interval)) layers = {} for i in range(num_layers): lower = y_min + i * y_interval upper = lower + y_interval # 创建掩码，筛选当前层的点 mask = (points[:, 1] >= lower) & (points[:, 1] < upper) layer_points = points[mask] if len(layer_points) > 0: layer_pcd = o3d.geometry.PointCloud() layer_pcd.points = o3d.utility.Vector3dVector(layer_points) layers[lower] = layer_pcd print(f"按高度分割完成，共{len(layers)}层") return layers def process_layers(layers, z_interval=0.2, x_interval=0.2): """ 处理每层点云，按Z轴分块，每块内按X轴排序，并计算块的平均坐标 Args: layers: 分层结果字典 z_interval: Z轴(深度)分块大小(米) x_interval: X轴(水平)分块大小(米) Returns: 处理结果字典: {(高度下限, 深度下限, 水平下限): { "point_count": 点数, "avg_coords": 平均坐标(x,y,z) }} """ processed_blocks = {} # 按高度从高到低处理 sorted_layers = sorted(layers.keys(), reverse=True) for y_lower in sorted_layers: layer_pcd = layers[y_lower] layer_points = np.asarray(layer_pcd.points) # 获取当前层Z轴范围 z_min, z_max = np.min(layer_points[:, 2]), np.max(layer_points[:, 2]) # 按Z轴(深度)从远到近分块 num_z_blocks = int(np.ceil((z_max - z_min) / z_interval)) for i in range(num_z_blocks): z_lower = z_min + i * z_interval z_upper = z_lower + z_interval # 创建Z轴掩码 z_mask = (layer_points[:, 2] >= z_lower) & (layer_points[:, 2] < z_upper) z_block_points = layer_points[z_mask] if len(z_block_points) > 0: # 获取当前块X轴范围 x_min, x_max = np.min(z_block_points[:, 0]), np.max(z_block_points[:, 0]) # 按X轴(水平)从右到左分块 num_x_blocks = int(np.ceil((x_max - x_min) / x_interval)) for j in range(num_x_blocks): x_lower = x_min + j * x_interval x_upper = x_lower + x_interval # 创建X轴掩码 x_mask = (z_block_points[:, 0] >= x_lower) & (z_block_points[:, 0] < x_upper) x_block_points = z_block_points[x_mask] if len(x_block_points) > 0: # 计算块的平均坐标 avg_coords = np.mean(x_block_points, axis=0) # 保存块信息，包含点数和平均坐标 block_key = (y_lower, z_lower, x_lower) processed_blocks[block_key] = { "point_count": len(x_block_points), "avg_coords": avg_coords } print(f"处理完成，共{len(processed_blocks)}个块") return processed_blocks def print_block_statistics(processed_blocks): """打印每个块的统计信息，包含平均坐标""" if not processed_blocks: print("没有可统计的块数据") return print("\n=== 块统计结果 ===") print("-" * 70) print("高度下限(m)\t深度下限(m)\t水平下限(m)\t点数\t\t平均坐标(x,y,z)") print("-" * 70) # 按高度从高到低、深度从远到近、水平从右到左排序 sorted_blocks = sorted( processed_blocks.items(), key=lambda x: (-x[0][0], x[0][1], x[0][2]) # 负号表示降序 ) for i, (block_key, block_data) in enumerate(sorted_blocks): y_lower, z_lower, x_lower = block_key point_count = block_data["point_count"] avg_x, avg_y, avg_z = block_data["avg_coords"] print( f"{y_lower:.2f}\t\t{z_lower:.2f}\t\t{x_lower:.2f}\t\t{point_count}\t\t({avg_x:.2f}, {avg_y:.2f}, {avg_z:.2f})") print("-" * 70) total_blocks = len(processed_blocks) total_points = sum(block["point_count"] for block in processed_blocks.values()) print(f"总计块数: {total_blocks}") print(f"总计点数: {total_points}") def save_block_statistics(processed_blocks, output_file="block_statistics.txt"): """将块统计信息保存到文件，包含平均坐标""" if not processed_blocks: print("没有可保存的块数据") return try: with open(output_file, &#39;w&#39;) as f: f.write("=== 块统计结果 ===\n") f.write("-" * 70 + "\n") f.write("高度下限(m)\t深度下限(m)\t水平下限(m)\t点数\t\t平均坐标(x,y,z)\n") f.write("-" * 70 + "\n") # 按高度从高到低、深度从远到近、水平从右到左排序 sorted_blocks = sorted( processed_blocks.items(), key=lambda x: (-x[0][0], x[0][1], x[0][2]) ) for (block_key, block_data) in sorted_blocks: y_lower, z_lower, x_lower = block_key point_count = block_data["point_count"] avg_x, avg_y, avg_z = block_data["avg_coords"] f.write( f"{y_lower:.2f}\t\t{z_lower:.2f}\t\t{x_lower:.2f}\t\t{point_count}\t\t({avg_x:.2f}, {avg_y:.2f}, {avg_z:.2f})\n") f.write("-" * 70 + "\n") f.write(f"总计块数: {len(processed_blocks)}\n") f.write(f"总计点数: {sum(block[&#39;point_count&#39;] for block in processed_blocks.values())}\n") print(f"统计结果已保存到: {output_file}") except Exception as e: print(f"保存统计结果失败: {e}") def main(): """主函数""" # 设置参数 FILE_PATH = "pointcloud_data/pointcloud_20250703_144541.pcd" # 修改为实际文件路径 Y_INTERVAL = 1 # 高度(Y轴)分层间隔(米) Z_INTERVAL = 1 # 深度(Z轴)分块间隔(米) X_INTERVAL = 1 # 水平(X轴)分块间隔(米) OUTPUT_FILE = "block_statistics.txt" # 统计结果输出文件 print("\n=== 点云码垛处理工具 ===") # 读取点云 pcd = read_pointcloud(FILE_PATH) if not pcd: return # 获取点云范围 bounds = get_pointcloud_bounds(pcd) print("\n点云范围:") print(f"X轴(水平): {bounds[&#39;x&#39;][0]:.2f}m ~ {bounds[&#39;x&#39;][1]:.2f}m") print(f"Y轴(高度): {bounds[&#39;y&#39;][0]:.2f}m ~ {bounds[&#39;y&#39;][1]:.2f}m") print(f"Z轴(深度): {bounds[&#39;z&#39;][0]:.2f}m ~ {bounds[&#39;z&#39;][1]:.2f}m") # 按高度分层 print(f"\n正在按高度分层 (间隔: {Y_INTERVAL}m)...") layers = segment_by_height(pcd, Y_INTERVAL) # 处理每层，按深度和水平位置分块，并计算平均坐标 print(f"\n正在按深度和水平位置分块 (深度间隔: {Z_INTERVAL}m, 水平间隔: {X_INTERVAL}m)...") processed_blocks = process_layers(layers, Z_INTERVAL, X_INTERVAL) # 打印块统计信息 print_block_statistics(processed_blocks) # 保存块统计信息到文件 save_block_statistics(processed_blocks, OUTPUT_FILE) print("\n=== 处理完成 ===") if __name__ == "__main__": main()这是读取点云文件，要删去距离大于0.55m和小于0.3m的点云块
07-04
我们使用Open3D处理点云数据，目标：删除距离大于0.55米和小于0.3米的点云块（即点云中每个点到某个参考点的距离不在[0.3,0.55]区间内的点）。这里假设参考点通常是坐标原点(0,0,0)，但也可以是其他点。如果没有特别...
import cv2 import numpy as np from scipy.spatial import distance as dist def preprocess_image(img_path): """图像预处理：灰度化、高斯模糊、边缘检测""" image = cv2.imread(img_path) gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) blurred = cv2.GaussianBlur(gray, (7, 7), 0) edged = cv2.Canny(blurred, 50, 100) return image, edged def get_contours(edged): """获取轮廓并按从左到右排序""" cnts = cv2.findContours(edged.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) cnts = cnts[0] if len(cnts) == 2 else cnts[1] return sorted(cnts, key=lambda x: cv2.boundingRect(x)[0]) def measure_with_reference(ref_img_path, target_img_path, ref_width_nm): """主测量函数""" # 处理参考图 ref_img, ref_edged = preprocess_image(ref_img_path) ref_cnts = get_contours(ref_edged) # 处理目标图 target_img, target_edged = preprocess_image(target_img_path) target_cnts = get_contours(target_edged) # 计算像素/纳米比例 ref_box = cv2.minAreaRect(ref_cnts[0]) ref_pixels = max(ref_box[1]) pixels_per_nm = ref_pixels / ref_width_nm # 测量目标图尺寸 results = [] for (i, c) in enumerate(target_cnts): box = cv2.minAreaRect(c) (_, (w, h), _) = box size_nm = max(w, h) / pixels_per_nm results.append(round(size_nm, 2)) return results if __name__ == "__main__": # 使用示例 reference_size_nm = 33.12 # 参考图中已知尺寸(nm) measurements = measure_with_reference( "reference.png", "target.png", reference_size_nm ) print(f"测量结果(nm): {measurements}")
06-17
绘制结果并输出测量值我们将参考引用[1]中的方法，同时结合引用[2][3][4]中的优化技巧。代码解析如下：</think>### OpenCV 图像预处理与轮廓检测实现尺寸测量代码解析 以下是通过 OpenCV 实现物体尺寸测量的完整...
import numpy as np from scipy.optimize import minimize from scipy.special import expit # Sigmoid 函数 # 假设有三名选手 A, B, C items = [&#39;A&#39;, &#39;B&#39;, &#39;C&#39;] n_items = len(items) # 比赛数据 (winner, loser) comparisons = [ (&#39;A&#39;, &#39;B&#39;), (&#39;B&#39;, &#39;C&#39;), (&#39;A&#39;, &#39;C&#39;), (&#39;A&#39;, &#39;B&#39;), (&#39;B&#39;, &#39;C&#39;) ] # 建立选手索引 item_to_index = {item: idx for idx, item in enumerate(items)} # 初始化得分 initial_scores = np.zeros(n_items) # 损失函数（-log Sigmoid） def loss_function(scores): loss = 0 for winner, loser in comparisons: winner_idx = item_to_index[winner] loser_idx = item_to_index[loser] # 差值计算 diff = scores[winner_idx] - scores[loser_idx] # -log Sigmoid 损失 loss += np.log(1 + np.exp(-diff)) return loss # 优化分数 result = minimize(loss_function, initial_scores, method=&#39;BFGS&#39;) optimized_scores = result.x # 打印优化结果 print("Optimized Scores:") for item, score in zip(items, optimized_scores): print(f"{item}: {score:.3f}") # 计算排名 ranking = sorted(zip(items, optimized_scores), key=lambda x: x[1], reverse=True) print("\nRanking:") for rank, (item, score) in enumerate(ranking, 1): print(f"{rank}. {item} (Score: {score:.3f})") ————————————————
06-06
我们面对的问题是实现一个排名优化算法，使用最大化似然估计方法（MLE）来估计选手的排名（或实力分数）。这通常应用于类似Elo排名系统或Bradley-Terry模型中。在Bradley-Terry模型中，我们通过选手之间的比赛结果来...
python3排序 sorted(key=lambda)
anqiu4023的博客
01-10 4171
使用python对列表（list）进行排序，说简单也简单，说复杂也复杂，我一开始学的时候也搞不懂在说什么，只能搜索一些英文文章看看讲解，现在积累了一些经验，写在这里跟大家分享，我们通过例子来详细解释一下函数sorted的具体用法： 先创建一个列表a ...
python sorted(data, key=lambda _:_[0]) 排序解释
richand112233的博客
05-03 3701
>>>data = ([1, 4, 3], [3, 2, 5], [5, 1, 2], [4, 3, 1], [2, 5, 3]) >>>sorted(data, key=lambda _: _[0]) [[1, 4, 3], [2, 5, 3], [3, 2, 5], [4, 3, 1], [5, 1, 2]] >>>sorted(data...
python函数--sorted函数和lambda函数
xiaozhiamy的博客
08-21 6141
reduce(function,sequence)：function接收的参数个数只能为2，先把sequence中第一个值和第二个值当参数传给function，再把function的返回值和第三个值当参数传给function，然后只返回一个结果。filter(function,sequence)：对sequence中的item依次执行function(item)，将执行结果为True的item组成一个List/String/Tuple(取决于sequence的类型)返回。1 简单列表(list)排序。
sorted函数key关键字结合lambda函数用法
hdddddddd1234567的博客
02-16 496
参数结合使用时，你可以方便地根据序列中每个元素的某个属性或计算结果来排序。是一个匿名函数，它接受一个元组作为输入（即列表中的人名年龄对），并返回元组的第二个元素（年龄）。是Python中的匿名函数，它允许你快速定义一个简单的、单行的、无需命名的函数。函数是一个内置函数，用于对任何可迭代对象（如列表、元组等）进行排序。函数会根据每个人的年龄对整个列表进行排序，而不是直接比较整个元组。将是按照年龄升序排列的新列表。
python——sort函数sorted函数以及lambda函数
Nanran6的博客
12-23 5890
这个函数应该接受两个参数并返回一个负整数、零或正整数，表示第一个参数应该位于第二个参数之前、两者相等或第一个参数应该位于第二个参数之后。如果 cmp 参数未指定或为 None，则使用默认比较函数，即通过对象的 < 和 > 运算符进行比较。key 参数：这是一个可选参数，
python sorted函数和lambda函数
weixin_45016484的博客
10-15 360
描述： sorted()函数对所有可迭代的对象进行排序操作 语法： sorted(interable, cmp = None, key = None, reverse = False) 参数说明： iterable 可迭代对象 cmp 比较函数，具有两个参数，参数值都是从可迭代对象中取出，大于返回1，小于返回-1，等于返回0 key 用来进行比较元素，只有一个参数，参数可以取自可迭代对象，指定可迭代对象中的元素进行排序 reverse 排序规则，ture为降序，false为升序（默认） 描述： lambd
python sorted按照多个key值排序（包括lambda和自定义函数）
yangyanbao8389的博客
12-01 1万+
sorted函数可以根据多个key值进行数据的排序，按照key值传入的顺序依次进行，当前面元素相同时，根据后面的key值继续排序。 data = [(12, 24), (12, 15), (15, 24), (7, 30), (30, 24)] print(sorted(data, key=lambda x:(x[0], x[1]))) #根据元祖第一个值升序排序，若第一个值相等则根据第二个值升序排序 print(sorted(data, key=lambda x:(x[0], -x[1...
Python sorted 函数：Key参数，以及lambda 函数与常规写法区别
STR_Liang的博客
06-28 825
Python sorted 函数：Key参数，以及lambda 函数与常规写法区别 第一种方式： ous = sorted(ouFilter.ous, key=lambda ou:ou.path) 使用 lambda 函数作为排序的关键字，这是一个简洁、明了的方式。lambda 函数在 Python 中表示一个简 单的匿名函数，它没有自己的名字，因此在代码中不需要为它预留名字。在排序的上下文中，key 参数通 常用于指定一个函数，该函数应用在输入序列的每一个元素上，其返回值被排序函数使用 第二种方式：
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值