lists
模块
列表
模块摘要
列表处理功能。
描述
该模块包含列表处理功能。
除非另有说明,否则所有函数都假定位置编号从1开始。也就是说,列表的第一个元素位于位置1。
两个条款T1
和T2
比较相等T1 == T2
评估为true
.他们匹配如果T1 =:= T2
评估为true
...
无论何时序函数F
作为参数,则假定下列属性持有F
对于所有x,y和z:
- 如果x
F
y和yF
x,则x = y(F
是反对称的)。
- 如果x
F
y和yF
z,则xF
z(F
是传递性的)。
- xFy或yFx(F是总数)。
一个典型的排序函数的例子小于或等于:=</2。
输出
all(Pred, List) -> boolean()
类型
Pred = fun((Elem :: T) -> boolean())
List = [T]
T = term()
如果对于List中的所有的元素Elem,Pred(ELEM)返回true,否则返回为false。
any(Pred, List) -> boolean()
类型
Pred = fun((Elem :: T) -> boolean())
List = [T]
T = term()
如果对于List中的至少一个元素Elem,Pred(ELEM)返回true,否则返回为false。
append(ListOfLists) -> List1
Types
ListOfLists = [List]
List = List1 = [T]
T = term()
返回ListOfLists的所有子列表已被追加的列表。
示例:
> lists:append([[1, 2, 3], [a, b], [4, 5, 6]]).
[1,2,3,a,b,4,5,6]
append(List1, List2) -> List3
Types
List1 = List2 = List3 = [T]
T = term()
返回一个新的列表List3,它由List1的元素和后面的List2的元素组成。
示例:
> lists:append("abc", "def").
"abcdef"
lists:append(A, B) 相当于 A ++ B。
concat(Things) -> string()
类型
Things = [Thing]
Thing = atom() | integer() | float() | string()
连接事物元素的文本表示。的元件的东西可以是原子,整数,浮点数,或字符串。
示例:
> lists:concat([doc, '/', file, '.', 3]).
"doc/file.3"
delete(Elem, List1) -> List2
类型
Elem = T
List1 = List2 = [T]
T = term()
返回List1的副本,其中与Elem匹配的第一个元素将被删除,如果存在这样的元素。
droplast(List) -> InitList
类型
List = [T, ...]
InitList = [T]
T = term()
删除列表的最后一个元素。这份名单是为非空,否则该功能与崩溃function_clause。
dropwhile(Pred, List1) -> List2
类型
Pred = fun((Elem :: T) -> boolean())
List1 = List2 = [T]
T = term()
从List1中删除元素Elem,而Pred(Elem)返回true并返回剩余列表。
duplicate(N, Elem) -> List
类型
N = integer() >= 0
Elem = T
List = [T]
T = term()
返回包含术语Elem的N个副本的列表。
Example:
> lists:duplicate(5, xx).
[xx,xx,xx,xx,xx]
filter(Pred, List1) -> List2
Types
Pred = fun((Elem :: T) -> boolean())
List1 = List2 = [T]
T = term()
List2 is a list of all elements Elem in List1 for which Pred(Elem) returns true.
列表2是所有元素的列表ELEM在列表1,当Pred(Elem) 返回真。
filtermap(Fun, List1) -> List2
Types
Fun = fun((Elem) -> boolean() | {true, Value})
List1 = [Elem]
List2 = [Elem | Value]
Elem = Value = term()
返回Fun(Elem)上连续元素ELEM的列表1。 Fun/1必须返回一个布尔值或一个元组{true, Value}。该函数返回Fun为其返回新值的元素列表,其中true值与{true,Elem}同义 。
也就是说,filtermap的行为就好像它已被定义如下:
filtermap(Fun, List1) ->
lists:foldr(fun(Elem, Acc) ->
case Fun(Elem) of
false -> Acc;
true -> [Elem|Acc];
{true,Value} -> [Value|Acc]
end
end, [], List1).
示例:
> lists:filtermap(fun(X) -> case X rem 2 of 0 -> {true, X div 2}; _ -> false end end, [1,2,3,4,5]).
[1,2]
flatlength(DeepList) -> integer() >= 0
类型
DeepList = [term() | DeepList]
相当于length(flatten(DeepList)),但效率更高。
flatmap(Fun, List1) -> List2
类型
Fun = fun((A) -> [B])
List1 = [A]
List2 = [B]
A = B = term()
从A到 B的列表以及A s(List1)的列表中获取一个函数,并通过将函数应用于List1中的每个元素并附加结果列表来 生成一个 B列表。
也就是说,flatmap的行为就好像它已被定义如下:
flatmap(Fun, List1) ->
append(map(Fun, List1)).
示例:
> lists:flatmap(fun(X)->[X,X] end, [a,b,c]).
[a,a,b,b,c,c]
flatten(DeepList) -> List
类型
DeepList = [term() | DeepList]
List = [term()]
返回DeepList的展平版本。
flatten(DeepList, Tail) -> List
Types
DeepList = [term() | DeepList]
Tail = List = [term()]
返回尾部Tail追加的DeepList的扁平版本。
foldl(Fun, Acc0, List) -> Acc1
Types
Fun = fun((Elem :: T, AccIn) -> AccOut)
Acc0 = Acc1 = AccIn = AccOut = term()
List = [T]
T = term()
调用Fun(Elem, AccIn) 上连续元素一的名单,从AccIn == Acc0.Fun/2必须返回一个新的累加器,并将其传递给下一个调用。该函数返回累加器的最终值。如果列表为空,则返回Acc0。
示例:
> lists:foldl(fun(X, Sum) -> X + Sum end, 0, [1,2,3,4,5]).
15
> lists:foldl(fun(X, Prod) -> X * Prod end, 1, [1,2,3,4,5]).
120
foldr(Fun, Acc0, List) -> Acc1
类型
Fun = fun((Elem :: T, AccIn) -> AccOut)
Acc0 = Acc1 = AccIn = AccOut = term()
List = [T]
T = term()
像foldl/3一样,但列表从右向左遍历。
示例:
> P = fun(A, AccIn) -> io:format("~p ", [A]), AccIn end.
#Fun<erl_eval.12.2225172>
> lists:foldl(P, void, [1,2,3]).
1 2 3 void
> lists:foldr(P, void, [1,2,3]).
3 2 1 void
foldl/3是尾递归的,通常比foldr/3更受欢迎。
join(Sep, List1) -> List2
类型
Sep = T
List1 = List2 = [T]
T = term()
插入Sep在各元件之间的List1。对空列表和单例列表没有影响。例如:
> lists:join(x, [a,b,c]).
[a,x,b,x,c]
> lists:join(x, [a]).
[a]
> lists:join(x, []).
[]
foreach(Fun, List) -> ok
类型
Fun = fun((Elem :: T) -> term())
List = [T]
T = term()
调用Fun(Elem)对每个元素ELEM在列表。此功能用于其副作用,并且评估顺序被定义为与列表中元素的顺序相同。
keydelete(Key, N, TupleList1) -> TupleList2
类型
Key = term()
N = integer() >= 1
1..tuple_size(Tuple)
TupleList1 = TupleList2 = [Tuple]
Tuple = tuple()
如果有这样一个元组,则返回TupleList1的副本,其中第N个元素与Key相等的元组的第一次出现被删除。
keyfind(Key, N, TupleList) -> Tuple | false
类型
Key = term()
N = integer() >= 1
1..tuple_size(Tuple)
TupleList = [Tuple]
Tuple = tuple()
在元组TupleList的列表中搜索第N个元素与Key相等的元组。如果找到这样的元组,则返回Tuple,否则返回false。
keymap(Fun, N, TupleList1) -> TupleList2
类型
Fun = fun((Term1 :: term()) -> Term2 :: term())
N = integer() >= 1
1..tuple_size(Tuple)
TupleList1 = TupleList2 = [Tuple]
Tuple = tuple()
返回元组列表,其中对于TupleList1中的每个元组,元组的第N个元素Term1已被调用Fun(Term1)的结果替换。
示例:
> Fun = fun(Atom) -> atom_to_list(Atom) end.
#Fun<erl_eval.6.10732646>
2> lists:keymap(Fun, 2, [{name,jane,22},{name,lizzie,20},{name,lydia,15}]).
[{name,"jane",22},{name,"lizzie",20},{name,"lydia",15}]
keymember(Key, N, TupleList) -> boolean()
类型
Key = term()
N = integer() >= 1
1..tuple_size(Tuple)
TupleList = [Tuple]
Tuple = tuple()
如果 TupleList中的第N个元素的值等于Key,则返回true ;否则返回false。
keymerge(N,TupleList1,TupleList2) - > TupleList3
类型
N = integer() >= 1
1..tuple_size(Tuple)
TupleList1 = [T1]
TupleList2 = [T2]
TupleList3 = [T1 | T2]
T1 = T2 = Tuple
Tuple = tuple()
返回通过合并TupleList1和TupleList2形成的排序列表。合并在每个元组的第N个元素上执行。无论TupleList1和TupleList2必须键排序评估此功能之前。当两个元组比较相等时,来自TupleList1的元组在TupleList2的元组之前被选取。
keyreplace(Key, N, TupleList1, NewTuple) -> TupleList2
类型
Key = term()
N = integer() >= 1
1..tuple_size(Tuple)
TupleList1 = TupleList2 = [Tuple]
NewTuple = Tuple
Tuple = tuple()
如果存在这样的元组T,则返回TupleList1的副本,其中第N个元素与Key相等的T元组的第一次出现被替换为NewTuple。
keysearch(Key, N, TupleList) -> {value, Tuple} | false
类型
Key = term()
N = integer() >= 1
1..tuple_size(Tuple)
TupleList = [Tuple]
Tuple = tuple()
在元组TupleList的列表中搜索第N个元素与Key相等 的元组。如果找到这样的元组,则返回{value,Tuple},否则返回false。
注意
为了向后兼容,此功能被保留。功能 keyfind / 3 通常更方便。
keysort(N, TupleList1) -> TupleList2
类型
N = integer() >= 1
1..tuple_size(Tuple)
TupleList1 = TupleList2 = [Tuple]
Tuple = tuple()
返回包含列表TupleList1的排序元素的列表。对元组的第N个元素执行排序。排序稳定。
keystore(Key, N, TupleList1, NewTuple) -> TupleList2
类型
Key = term()
N = integer() >= 1
1..tuple_size(Tuple)
TupleList1 = [Tuple]
TupleList2 = [Tuple, ...]
NewTuple = Tuple
Tuple = tuple()
如果存在这样的元组T,则返回TupleList1的副本,其中第N个元素与Key相等的元组T的第一次出现被NewTuple替换。如果不存在这样的元组T,则返回[NewTuple]已附加到结尾的TupleList1的副本。
keytake(Key, N, TupleList1) -> {value, Tuple, TupleList2} | false
类型
Key = term()
N = integer() >= 1
1..tuple_size(Tuple)
TupleList1 = TupleList2 = [tuple()]
Tuple = tuple()
在元组TupleList1的列表中搜索第N个元素与Key相等的元组。如果找到这样的元组,则返回{value,Tuple,TupleList2},否则返回false。TupleList2是副本TupleList1,其中第一次出现的元组已被删除。
last(List) -> Last
类型
List = [T, ...]
Last = T
T = term()
返回List中的最后一个元素。
map(Fun, List1) -> List2
类型
Fun = fun((A) -> B)
List1 = [A]
List2 = [B]
A = B = term()
需要从函数甲s到乙s,且列表甲S和产生的列表乙通过将所述函数应用于列表中的每个要素s。该函数用于获取返回值。评估顺序取决于实施。
mapfoldl(Fun, Acc0, List1) -> {List2, Acc1}
类型
Fun = fun((A, AccIn) -> {B, AccOut})
Acc0 = Acc1 = AccIn = AccOut = term()
List1 = [A]
List2 = [B]
A = B = term()
示例:
将列表中的元素总结在一起并同时加倍:
> lists:mapfoldl(fun(X, Sum) -> {2*X, X+Sum} end,
0, [1,2,3,4,5]).
{[2,4,6,8,10],15}
mapfoldr(Fun, Acc0, List1) -> {List2, Acc1}
类型
Fun = fun((A, AccIn) -> {B, AccOut})
Acc0 = Acc1 = AccIn = AccOut = term()
List1 = [A]
List2 = [B]
A = B = term()
max(List) -> Max
类型
List = [T, ...]
Max = T
T = term()
返回List的第一个元素,它比较大于或等于List的所有其他元素。
member(Elem, List) -> boolean()
Types
Elem = T
List = [T]
T = term()
如果Elem匹配List的某个元素,则返回true,否则返回false。
merge(ListOfLists) -> List1
类型
ListOfLists = [List]
List = List1 = [T]
T = term()
返回通过合并ListOfLists的所有子列表形成的排序列表。在评估此功能之前,必须对所有子列表进行排序。当两个元素比较相等时,ListOfLists中具有最低位置的子列表中的元素将在其他元素之前被选取。
merge(List1, List2) -> List3
类型
List1 = [X]
List2 = [Y]
List3 = [X | Y]
X = Y = term()
返回通过合并List1和List2形成的排序列表。这两个列表1和列表2必须评估该功能前进行排序。当两个元素比较相等时,来自List1的元素在来自List2的元素之前被选取。
merge(Fun, List1, List2) -> List3
类型
Fun = fun((A, B) -> boolean())
List1 = [A]
List2 = [B]
List3 = [A | B]
A = B = term()
返回通过合并List1和List2形成的排序列表。这两个列表1和列表2必须按照排序顺序功能玩转评估此功能之前。如果A在排序中比较小于或等于B,则乐趣(A,B)将返回true,否则为false。当两个元素比较相等时,来自List1的元素在来自List2的元素之前被选取。
merge3(List1, List2, List3) -> List4
类型
List1 = [X]
List2 = [Y]
List3 = [Z]
List4 = [X | Y | Z]
X = Y = Z = term()
返回通过合并List1,List2和List3形成的排序列表。在评估此功能之前,必须对List1,List2和List3进行排序。当两个元素比较相等时,来自List1的元素(如果存在这样的元素)在其他元素之前被选取,否则来自List2的元素被选择在来自List3的元素之前。
min(List) -> Min
Types
List = [T, ...]
Min = T
T = term()
返回List的第一个元素,它比较小于或等于List的所有其他元素。
nth(N, List) -> Elem
Types
N = integer() >= 1
1..length(List)
List = [T, ...]
Elem = T
T = term()
返回List的第N个元素。
示例:
> lists:nth(3, [a, b, c, d, e]).
c
nthtail(N, List) -> Tail
类型
N = integer() >= 0
0..length(List)
List = [T, ...]
Tail = [T]
T = term()
返回List的第N个尾部,即从N + 1开始并继续到列表末尾的List的子列表。
示例
> lists:nthtail(3, [a, b, c, d, e]).
[d,e]
> tl(tl(tl([a, b, c, d, e]))).
[d,e]
> lists:nthtail(0, [a, b, c, d, e]).
[a,b,c,d,e]
> lists:nthtail(5, [a, b, c, d, e]).
[]
partition(Pred, List) -> {Satisfying, NotSatisfying}
类型
Pred = fun((Elem :: T) -> boolean())
List = Satisfying = NotSatisfying = [T]
T = term()
分区列表分为两个列表,其中第一个列表包含Pred(Elem)返回true的所有元素,第二个列表包含Pred(Elem)返回false的所有元素。
示例:
> lists:partition(fun(A) -> A rem 2 == 1 end, [1,2,3,4,5,6,7]).
{[1,3,5,7],[2,4,6]}
> lists:partition(fun(A) -> is_atom(A) end, [a,b,1,c,d,2,3,4,e]).
{[a,b,c,d,e],[1,2,3,4]}
有关分区列表的不同方式,请参阅splitwith/2。
prefix(List1, List2) -> boolean()
类型
List1 = List2 = [T]
T = term()
如果List1是List2的前缀,则返回true,否则返回false。
reverse(List1) -> List2
类型
List1 = List2 = [T]
T = term()
以相反顺序返回List1中元素的列表。
reverse(List1, Tail) -> List2
Types
List1 = [T]
Tail = term()
List2 = [T]
T = term()
以相反顺序返回List1中元素的列表,并附加Tailappended。
示例:
> lists:reverse([1, 2, 3, 4], [a, b, c]).
[4,3,2,1,a,b,c]
seq(From, To) -> Seq
seq(From, To, Incr) -> Seq
类型
From = To = Incr = integer()
Seq = [integer()]
返回以From开头的整数序列,并包含将Incr添加到前一个元素的连续结果,直到To达到或通过(在后一种情况下,To不是序列的元素)。Incr默认为1。
失败:
- 如果
To < From - Incr
和Incr > 0
。
- 如果
To > From - Incr
和Incr < 0
。
- 如果
Incr =:= 0
和From =/= To
。
下列等式适用于所有序列:
length(lists:seq(From, To)) =:= To - From + 1
length(lists:seq(From, To, Incr)) =:= (To - From + Incr) div Incr
例子:
> lists:seq(1, 10).
[1,2,3,4,5,6,7,8,9,10]
> lists:seq(1, 20, 3).
[1,4,7,10,13,16,19]
> lists:seq(1, 0, 1).
[]
> lists:seq(10, 6, 4).
[]
> lists:seq(1, 1, 0).
[1]
sort(List1) -> List2
类型
返回包含排序元素的列表List1
。
sort(Fun, List1) -> List2
类型
根据ordering function
Fun
。返回包含排序元素的列表List1
。如果A
比较小于或等于B
,Fun(A, B)
则返回true
,否则返回false
。
split(N, List1) -> {List2, List3}
类型
0..length(List1)
拆分List1
成List2
和List3
。List2
包含第一个N
元素和List3
其余元素(第N
th尾)。
splitwith(Pred, List) -> {List1, List2}
类型
分区List
成两个列表根据Pred
。splitwith/2
表现如同它被定义如下:
splitwith(Pred, List) ->
{takewhile(Pred, List), dropwhile(Pred, List)}.
例子:
> lists:splitwith(fun(A) -> A rem 2 == 1 end, [1,2,3,4,5,6,7]).
{[1],[2,3,4,5,6,7]}
> lists:splitwith(fun(A) -> is_atom(A) end, [a,b,1,c,d,2,3,4,e]).
{[a,b],[1,c,d,2,3,4,e]}
有关分区列表的另一种方式,请参阅partition/2
。
sublist(List1, Len) -> List2
类型
返回List1
从位置1开始并具有(最大)Len
元素的子列表。Len
超出列表的长度并不是错误,在这种情况下,整个列表将被返回。
sublist(List1, Start, Len) -> List2
类型
1..(length(List1)+1)
返回以List1
(最大)Len
元素开始Start
的子列表。超出列表长度并不是Start+Len
错误。
例子:
> lists:sublist([1,2,3,4], 2, 2).
[2,3]
> lists:sublist([1,2,3,4], 2, 5).
[2,3,4]
> lists:sublist([1,2,3,4], 5, 2).
[]
subtract(List1, List2) -> List3
类型
按照以下过程返回作为List3
副本的新列表List1
:对于其中的每个元素List2
,其第一个出现的元素将List1
被删除。
例子:
> lists:subtract("123212", "212").
"312".
lists:subtract(A, B)
相当于A -- B
。
警告
在复杂lists:subtract(A, B)
成正比length(A)*length(B)
,这意味着它是非常缓慢的,如果这两个A
和B
很长的列表。(如果两个列表都很长,使用有序列表和更好的选择是更好的选择ordsets:subtract/2
。
suffix(List1, List2) -> boolean()
类型
返回true
如果 List1
是后缀List2
,否则返回false
。
sum(List) -> number()
类型
返回中的元素总和List
。
takewhile(Pred, List1) -> List2
类型
Elem
从List1
while Pred(Elem)
返回元素true
,也就是说,函数返回列表中所有元素满足谓词的最长前缀。
ukeymerge(N, TupleList1, TupleList2) -> TupleList3
类型
1..tuple_size(Tuple)
返回合并TupleList1
和所形成的排序列表TupleList2
。合并在N
每个元组的第th个元素上执行。在评估此功能之前,两者TupleList1
和TupleList2
必须按键分类,不得重复。当两个元组比较相等时,元组被从中TupleList1
挑选出来,并从中TupleList2
删除。
ukeysort(N, TupleList1) -> TupleList2
类型
1..tuple_size(Tuple)
返回一个包含列表的排序元素的列表TupleList1
,其中除了比较相等的元组的第一个元组之外的所有元素都已被删除。排序N
在元组的第th个元素上执行。
umerge(ListOfLists) -> List1
类型
返回合并所有子列表形成的排序列表ListOfLists
。在评估此功能之前,所有子列表必须进行排序并且不包含重复项。当两个元素比较相等时,位于最低位置的子列表中的元素ListOfLists
被选中,另一个被删除。
umerge(List1, List2) -> List3
类型
返回合并List1
和所形成的排序列表List2
。双方List1
并List2
必须进行分类和评估包含此功能之前,没有重复。当两个元素比较相等时,元素来自List1
被挑选,而来自元素的元素List2
被删除。
umerge(Fun, List1, List2) -> List3
类型
返回合并List1
和所形成的排序列表List2
。在评估此功能之前,List1
和List2
两者都必须根据ordering function
Fun
并且不包含重复项进行排序。如果A
比较小于或等于B
则Fun(A, B)
返回true
,否则返回false
。当两个元素比较相等时,来自List1
元素被挑选,而来自List2
元素被删除。
umerge3(List1, List2, List3) -> List4
类型
返回排序列表通过合并形成的List1
,List2
和List3
。所有的List1
,List2
以及List3
必须进行分类和评估包含此功能之前,没有重复。当两个元素比较相等时,List1
如果存在这样的元素,则从中List2
选择元素,否则从中拾取元素,而另一个元素被删除。
unzip(List1) -> {List2, List3}
类型
将两元组列表解压缩到两个列表中,其中第一个列表包含每个元组的第一个元素,第二个列表包含每个元组的第二个元素。
unzip3(List1) -> {List2, List3, List4}
类型
将三元组列表解压缩为三个列表,其中第一个列表包含每个元组的第一个元素,第二个列表包含每个元组的第二个元素,第三个列表包含每个元组的第三个元素。
usort(List1) -> List2
类型
返回包含排序元素的列表。List1
其中,除第一个元素外,所有元素都已被删除。
usort(Fun, List1) -> List2
类型
返回一个列表,其中包含List1
所有元素的排序元素,除了根据ordering function
Fun
已被删除的元素的第一个元素比较相等以外。如果比较小于或等于Fun(A, B)
则返回,否则返回。trueABfalse
zip(List1, List2) -> List3
类型
“Zips”将两个长度相等的列表合并成一个由两个元组组成的列表,其中每个元组的第一个元素从第一个列表中提取,第二个元素从第二个列表中的相应元素中提取。
zip3(List1, List2, List3) -> List4
类型
“Zips”三个长度相等的列表为一个三元组列表,其中每个元组的第一个元素从第一个列表中提取,第二个元素从第二个列表中的相应元素中提取。第三个元素从第三个列表中的对应元素中提取。
zipwith(Combine, List1, List2) -> List3
类型
将两个长度相等的列表的元素组合成一个列表。对于X, Y
这两个列表中的每对列表元素,结果列表中的元素是Combine(X, Y)
。
zipwith(fun(X, Y) -> {X,Y} end, List1, List2)
等于zip(List1, List2)
...
例子:
> lists:zipwith(fun(X, Y) -> X+Y end, [1,2,3], [4,5,6]).
[5,7,9]
zipwith3(Combine, List1, List2, List3) -> List4
类型
将三个长度相等的列表的元素组合成一个列表。对于X, Y, Z
三个列表中每个列表元素的三元组,结果列表中的元素是Combine(X, Y, Z)
。
zipwith3(fun(X, Y, Z) -> {X,Y,Z} end, List1, List2, List3)
相当于zip3(List1, List2, List3)
。
例子:
> lists:zipwith3(fun(X, Y, Z) -> X+Y+Z end, [1,2,3], [4,5,6], [7,8,9]).
[12,15,18]
> lists:zipwith3(fun(X, Y, Z) -> [X,Y,Z] end, [a,b,c], [x,y,z], [1,2,3]).
[[a,x,1],[b,y,2],[c,z,3]]
本文档系腾讯云开发者社区成员共同维护,如有问题请联系 cloudcommunity@tencent.com