求教怎么能比较优雅的实现这个功能

"data":[
    {
        "file": "https://fvs.io/re.........",
        "label": "480p",
        "type": "mp4"
    },
    {
        "file": "https://fvs.io/redirector.......",
        "label": "720p",
        "type": "mp4"
    }
]

我想取出来 label 中清晰度最高的

Label

file

type

mp4

37 条回复 • 2019-04-30 12:23:17 +08:00

ErnieSauce

2019-04-29 18:57:35 +08:00

我一般使用 json 转数组，然后提取

ErnieSauce

2019-04-29 18:58:56 +08:00

@ErnieSauce 刚看到是在 python 区，这个不太清楚，应该也有类似的吧

hmxxmh

2019-04-29 19:15:42 +08:00 via Android

遍历取出字段 label 的值和对应的索引，比较大小留下大的索引，然后通过索引去取字典😂

entertainyou

2019-04-29 19:32:16 +08:00

max(list, key=lambda x: x['label']) // 需要根据需求修改 key 函数.

Leigg

2019-04-29 21:28:40 +08:00 via iPhone

@hmxxmh 遍历的时候就已经得到结果了，兄弟

warcraft1236

2019-04-29 21:53:29 +08:00

@Leigg 遍历的时候得不到吧，毕竟不知道后边是不是还有更大的值

zzxCNCZ

2019-04-29 21:55:46 +08:00

遍历一遍就能去取到最大的啦

luguhu

2019-04-29 22:09:34 +08:00

如果是 python sorted 可以自定义排序吧

Northxw

2019-04-29 22:23:27 +08:00

首先，这种 Json 格式一般来说是固定且有序的（不排除某些奇葩站点，不过我没遇见过），获取 -1 索引位置的就好；
然后，如果接口每次返回随机个数的 label，但是固定顺序的，len(data) 后获取 [-1] 个就好；
最后，如果随机个数且无序，建议用正则；第一次匹配数字，确定最大的，第二次在第一期确定基础之上，非贪婪正则匹配最近的 label。

zzz686970

2019-04-29 22:47:54 +08:00

@entertainyou 如果还有 1080p 那岂不是拿不到么？

linweibin

2019-04-29 23:06:56 +08:00

不知道楼主要什么语言，思路：冒泡排序取

zqx

2019-04-29 23:28:04 +08:00 via Android

js:
arr.sort((a,b)=>{
return Number(a.label)-Number(b.label)
})[0]

hundan

2019-04-29 23:36:18 +08:00 via Android

一边遍历一边按标签重新分组然后最后操作不同分组

LancerComet

2019-04-29 23:37:07 +08:00

[
{
"file": "https://fvs.io/re.........",
"label": "480p",
"type": "mp4"
},
{
"file": "https://fvs.io/redirector.......",
"label": "720p",
"type": "mp4"
},
{
"file": "https://fvs.io/redirector.......",
"label": "240p",
"type": "mp4"
},
{
"file": "https://fvs.io/redirector.......",
"label": "1080p",
"type": "mp4"
},
].reduce((prev, value) => parseInt(value.label) > parseInt(prev.label) ? value : prev)

icy37785

2019-04-30 00:44:50 +08:00

遍历一遍呀。

prolic

2019-04-30 01:15:46 +08:00

print(reduce(lambda x,y: x if x['label'] > y['label'] else y,json.loads(str).get('data')))
懒得格式化了，凑合看吧

vHypnos

2019-04-30 02:59:19 +08:00

sort 排序（ by lable ）然后返回最后一个 ( or 第一个）

Trim21

2019-04-30 03:14:27 +08:00 via Android

max(o['data'], key=lambda x:int(x['label'][:-1]))

aliao0019

2019-04-30 03:23:33 +08:00 via Android

遍历啊，为什么要去排序

hmxxmh

2019-04-30 08:00:53 +08:00 via Android

@linweibin 我也觉得有点类似冒泡排序😂

Foreverdxa

2019-04-30 08:32:39 +08:00

js 里的 reduce 可以实现，前面老哥都是很详细了。。。

zqx

2019-04-30 08:56:54 +08:00 via Android

js:
Math.max(arr.map((item)=>{return item.label}))

WuwuGin

2019-04-30 09:00:49 +08:00

啥排序啊，就取个最大值而已

nacosboy

2019-04-30 09:21:05 +08:00

maxResolution := 0

for _, d := range data {
if maxResolution < parseXXX(d.Label) {
maxResolution = parseXXX(d.Label)
}
}

return maxResolution

nacosboy

2019-04-30 09:22:38 +08:00

```go
func main() {
maxResolution := 0

for _, d := range data {
if maxResolution < parseXXX(d.Label) {
maxResolution = parseXXX(d.Label)
}
}

print(maxResolution)
}

```

zblongfei

2019-04-30 09:28:05 +08:00 via iPhone

遍历一边就能拿到手非常简单

daguaochengtang

2019-04-30 09:32:59 +08:00

@zqx 你这个表达式返回的是 NaN。第一，Math.max 不能接收数组。第二，label 是字符串，要转成数字
Math.max(...arr.map(item => parseInt(item.label)))

Chenamy2017

2019-04-30 10:01:17 +08:00

遍历
取每个 label，转数字，比较大小；如果大的这个对象就暂存
一遍下来就能拿到暂存的最大的对象了。

dicc

2019-04-30 10:03:12 +08:00

你们都忽略了在比较的时候 1080P < 480P 的问题..

fzzff

2019-04-30 10:05:10 +08:00

data = [
{
"file": "https://fvs.io/re.........",
"label": "480p",
"type": "mp4"
},
{
"file": "https://fvs.io/redirector.......",
"label": "1020p",
"type": "mp4"
},
{
"file": "https://fvs.io/redirector.......",
"label": "720p",
"type": "mp4"
}
]

data.sort(key=lambda d:int(d['label'][:-1]), reverse=True)
print(data[0])

dicc

2019-04-30 10:05:26 +08:00

sorted(a, key=lambda x:int(x['label'][:-1]), reverse=True)

第一个就是

inhzus

2019-04-30 10:08:21 +08:00

max(json.dumps(d)['data'], key=lambda x: int(x['label'][:-1]))

zqx

2019-04-30 10:34:13 +08:00

@nikolausliu 手机上打的，疏忽了。parseInt 可以将字符串中数字部分提取出来，而 Number 只能构造数值，最后应该用...展开数组给 max 函数

Akichu

2019-04-30 10:53:12 +08:00

用 js 的 ramda 库:
R.last(R.sortBy(R.prop('label'), data))

ccdrea

2019-04-30 10:54:30 +08:00

1.
max(data, key=lambda x: int(x['label'].replace('p','')))

2.
data.sort(key=lambda x:int(x['label'].replace('p','')))
data[-1]

ccdrea

2019-04-30 11:19:47 +08:00

补充:
from collections import OrderedDict

c = list(map(lambda x:OrderedDict(x),a))[-1]

# OrderedDict 实现一个 FIFO 得 dict

TommyLemon

2019-04-30 12:23:17 +08:00

能用 SQL 过滤最好，不能用就遍历再对比