Ik heb twee lijsten in Python, zoals deze:
temp1 = ['One', 'Two', 'Three', 'Four']
temp2 = ['One', 'Two']
Ik moet een derde lijst maken met items uit de eerste lijst die niet aanwezig zijn in de tweede. Uit het voorbeeld dat ik moet halen
temp3 = ['Three', 'Four']
Zijn er snelle manieren zonder cycli en controle?
Antwoord 1, autoriteit 100%
Om elementen op te halen die in temp1staan maar niet in temp2:
In [5]: list(set(temp1) - set(temp2))
Out[5]: ['Four', 'Three']
Pas op dat het asymmetrisch is :
In [5]: set([1, 2]) - set([2, 3])
Out[5]: set([1])
waar je zou verwachten/willen dat het gelijk is aan set([1, 3]). Als u set([1, 3])als uw antwoord wilt, kunt u set([1, 2]).symmetric_difference(set([2, 3])).
Antwoord 2, autoriteit 37%
De bestaande oplossingen bieden allemaal het een of het ander van:
- Sneller dan O(n*m) prestaties.
- Behoud de volgorde van de invoerlijst.
Maar tot nu toe heeft geen enkele oplossing beide. Als je beide wilt, probeer dan dit:
s = set(temp2)
temp3 = [x for x in temp1 if x not in s]
Prestatietest
import timeit
init = 'temp1 = list(range(100)); temp2 = [i * 2 for i in range(50)]'
print timeit.timeit('list(set(temp1) - set(temp2))', init, number = 100000)
print timeit.timeit('s = set(temp2);[x for x in temp1 if x not in s]', init, number = 100000)
print timeit.timeit('[item for item in temp1 if item not in temp2]', init, number = 100000)
Resultaten:
4.34620224079 # ars' answer
4.2770634955 # This answer
30.7715615392 # matt b's answer
De methode die ik heb gepresenteerd en het bewaren van de volgorde is ook (iets) sneller dan de set-aftrekking omdat er geen onnodige set hoeft te worden gemaakt. Het prestatieverschil zou meer opvallen als de eerste lijst aanzienlijk langer is dan de tweede en als hashen duur is. Hier is een tweede test die dit aantoont:
init = '''
temp1 = [str(i) for i in range(100000)]
temp2 = [str(i * 2) for i in range(50)]
'''
Resultaten:
11.3836875916 # ars' answer
3.63890368748 # this answer (3 times faster!)
37.7445402279 # matt b's answer
Antwoord 3, autoriteit 8%
Kan worden gedaan met behulp van de python XOR-operator.
- Hiermee worden de duplicaten in elke lijst verwijderd
- Hiermee wordt het verschil van temp1 van temp2 en temp2 van temp1 weergegeven.
set(temp1) ^ set(temp2)
Antwoord 4, autoriteit 7%
temp3 = [item for item in temp1 if item not in temp2]
Antwoord 5, autoriteit 2%
Het verschil tussen twee lijsten (zeg lijst1 en lijst2) kan worden gevonden met behulp van de volgende eenvoudige functie.
def diff(list1, list2):
c = set(list1).union(set(list2)) # or c = set(list1) | set(list2)
d = set(list1).intersection(set(list2)) # or d = set(list1) & set(list2)
return list(c - d)
of
def diff(list1, list2):
return list(set(list1).symmetric_difference(set(list2))) # or return list(set(list1) ^ set(list2))
Door de bovenstaande functie te gebruiken, kan het verschil gevonden worden met diff(temp2, temp1)of diff(temp1, temp2). Beide geven het resultaat ['Four', 'Three']. U hoeft zich geen zorgen te maken over de volgorde van de lijst of welke lijst als eerste moet worden gegeven.
Antwoord 6
Als je het verschil recursief wilt, heb ik een pakket voor python geschreven:
https://github.com/seperman/deepdiff
Installatie
Installeren vanaf PyPi:
pip install deepdiff
Voorbeeld van gebruik
Importeren
>>> from deepdiff import DeepDiff
>>> from pprint import pprint
>>> from __future__ import print_function # In case running on Python 2
Hetzelfde object wordt leeg geretourneerd
>>> t1 = {1:1, 2:2, 3:3}
>>> t2 = t1
>>> print(DeepDiff(t1, t2))
{}
Type item is gewijzigd
>>> t1 = {1:1, 2:2, 3:3}
>>> t2 = {1:1, 2:"2", 3:3}
>>> pprint(DeepDiff(t1, t2), indent=2)
{ 'type_changes': { 'root[2]': { 'newtype': <class 'str'>,
'newvalue': '2',
'oldtype': <class 'int'>,
'oldvalue': 2}}}
Waarde van een item is gewijzigd
>>> t1 = {1:1, 2:2, 3:3}
>>> t2 = {1:1, 2:4, 3:3}
>>> pprint(DeepDiff(t1, t2), indent=2)
{'values_changed': {'root[2]': {'newvalue': 4, 'oldvalue': 2}}}
Item toegevoegd en/of verwijderd
>>> t1 = {1:1, 2:2, 3:3, 4:4}
>>> t2 = {1:1, 2:4, 3:3, 5:5, 6:6}
>>> ddiff = DeepDiff(t1, t2)
>>> pprint (ddiff)
{'dic_item_added': ['root[5]', 'root[6]'],
'dic_item_removed': ['root[4]'],
'values_changed': {'root[2]': {'newvalue': 4, 'oldvalue': 2}}}
Tekenreeksverschil
>>> t1 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":"world"}}
>>> t2 = {1:1, 2:4, 3:3, 4:{"a":"hello", "b":"world!"}}
>>> ddiff = DeepDiff(t1, t2)
>>> pprint (ddiff, indent = 2)
{ 'values_changed': { 'root[2]': {'newvalue': 4, 'oldvalue': 2},
"root[4]['b']": { 'newvalue': 'world!',
'oldvalue': 'world'}}}
Tekenreeksverschil 2
>>> t1 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":"world!\nGoodbye!\n1\n2\nEnd"}}
>>> t2 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":"world\n1\n2\nEnd"}}
>>> ddiff = DeepDiff(t1, t2)
>>> pprint (ddiff, indent = 2)
{ 'values_changed': { "root[4]['b']": { 'diff': '--- \n'
'+++ \n'
'@@ -1,5 +1,4 @@\n'
'-world!\n'
'-Goodbye!\n'
'+world\n'
' 1\n'
' 2\n'
' End',
'newvalue': 'world\n1\n2\nEnd',
'oldvalue': 'world!\n'
'Goodbye!\n'
'1\n'
'2\n'
'End'}}}
>>>
>>> print (ddiff['values_changed']["root[4]['b']"]["diff"])
---
+++
@@ -1,5 +1,4 @@
-world!
-Goodbye!
+world
1
2
End
Type wijziging
>>> t1 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":[1, 2, 3]}}
>>> t2 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":"world\n\n\nEnd"}}
>>> ddiff = DeepDiff(t1, t2)
>>> pprint (ddiff, indent = 2)
{ 'type_changes': { "root[4]['b']": { 'newtype': <class 'str'>,
'newvalue': 'world\n\n\nEnd',
'oldtype': <class 'list'>,
'oldvalue': [1, 2, 3]}}}
Lijst verschil
>>> t1 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":[1, 2, 3, 4]}}
>>> t2 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":[1, 2]}}
>>> ddiff = DeepDiff(t1, t2)
>>> pprint (ddiff, indent = 2)
{'iterable_item_removed': {"root[4]['b'][2]": 3, "root[4]['b'][3]": 4}}
Lijstverschil 2:
>>> t1 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":[1, 2, 3]}}
>>> t2 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":[1, 3, 2, 3]}}
>>> ddiff = DeepDiff(t1, t2)
>>> pprint (ddiff, indent = 2)
{ 'iterable_item_added': {"root[4]['b'][3]": 3},
'values_changed': { "root[4]['b'][1]": {'newvalue': 3, 'oldvalue': 2},
"root[4]['b'][2]": {'newvalue': 2, 'oldvalue': 3}}}
Lijst verschil waarbij volgorde of duplicaten worden genegeerd: (met dezelfde woordenboeken als hierboven)
>>> t1 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":[1, 2, 3]}}
>>> t2 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":[1, 3, 2, 3]}}
>>> ddiff = DeepDiff(t1, t2, ignore_order=True)
>>> print (ddiff)
{}
Lijst met woordenboek:
>>> t1 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":[1, 2, {1:1, 2:2}]}}
>>> t2 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":[1, 2, {1:3}]}}
>>> ddiff = DeepDiff(t1, t2)
>>> pprint (ddiff, indent = 2)
{ 'dic_item_removed': ["root[4]['b'][2][2]"],
'values_changed': {"root[4]['b'][2][1]": {'newvalue': 3, 'oldvalue': 1}}}
Sets:
>>> t1 = {1, 2, 8}
>>> t2 = {1, 2, 3, 5}
>>> ddiff = DeepDiff(t1, t2)
>>> pprint (DeepDiff(t1, t2))
{'set_item_added': ['root[3]', 'root[5]'], 'set_item_removed': ['root[8]']}
Tuples met de naam:
>>> from collections import namedtuple
>>> Point = namedtuple('Point', ['x', 'y'])
>>> t1 = Point(x=11, y=22)
>>> t2 = Point(x=11, y=23)
>>> pprint (DeepDiff(t1, t2))
{'values_changed': {'root.y': {'newvalue': 23, 'oldvalue': 22}}}
Aangepaste objecten:
>>> class ClassA(object):
... a = 1
... def __init__(self, b):
... self.b = b
...
>>> t1 = ClassA(1)
>>> t2 = ClassA(2)
>>>
>>> pprint(DeepDiff(t1, t2))
{'values_changed': {'root.b': {'newvalue': 2, 'oldvalue': 1}}}
Objectkenmerk toegevoegd:
>>> t2.c = "new attribute"
>>> pprint(DeepDiff(t1, t2))
{'attribute_added': ['root.c'],
'values_changed': {'root.b': {'newvalue': 2, 'oldvalue': 1}}}
Antwoord 7
meest eenvoudige manier,
gebruik set().difference(set())
list_a = [1,2,3]
list_b = [2,3]
print set(list_a).difference(set(list_b))
antwoord is set([1])
kan als lijst afdrukken,
print list(set(list_a).difference(set(list_b)))
Antwoord 8
Als je echt op zoek bent naar prestaties, gebruik dan numpy!
Hier is het volledige notitieboek als een kern op github met vergelijking tussen lijst, numpy en panda’s.
https://gist.github.com/denfromufa/2821ff59b02e9482be15d27f2bbd4451
Antwoord 9
Probeer dit:
temp3 = set(temp1) - set(temp2)
Antwoord 10
ik doe mee omdat geen van de huidige oplossingen een tuple oplevert:
temp3 = tuple(set(temp1) - set(temp2))
alternatief:
#edited using @Mark Byers idea. If you accept this one as answer, just accept his instead.
temp3 = tuple(x for x in temp1 if x not in set(temp2))
Net als de andere niet-tuple antwoorden in deze richting, bewaart het de orde
Antwoord 11
Ik wilde iets dat twee lijsten zou bevatten en zou kunnen doen wat diffin bashdoet. Aangezien deze vraag het eerst opduikt wanneer je zoekt naar “python diff two lists” en niet erg specifiek is, zal ik posten wat ik heb bedacht.
Met behulp van SequenceMathervan difflibje kunt twee lijsten vergelijken zoals diffdat doet. Geen van de andere antwoorden zal u de positie vertellen waar het verschil optreedt, maar deze wel. Sommige antwoorden geven het verschil slechts in één richting aan. Sommigen herschikken de elementen. Sommige verwerken geen duplicaten. Maar deze oplossing geeft je een echt verschil tussen twee lijsten:
a = 'A quick fox jumps the lazy dog'.split()
b = 'A quick brown mouse jumps over the dog'.split()
from difflib import SequenceMatcher
for tag, i, j, k, l in SequenceMatcher(None, a, b).get_opcodes():
if tag == 'equal': print('both have', a[i:j])
if tag in ('delete', 'replace'): print(' 1st has', a[i:j])
if tag in ('insert', 'replace'): print(' 2nd has', b[k:l])
Dit geeft het volgende weer:
both have ['A', 'quick']
1st has ['fox']
2nd has ['brown', 'mouse']
both have ['jumps']
2nd has ['over']
both have ['the']
1st has ['lazy']
both have ['dog']
Als uw toepassing dezelfde veronderstellingen maakt als de andere antwoorden, profiteert u daar natuurlijk het meeste van. Maar als u op zoek bent naar een echte diff-functionaliteit, dan is dit de enige manier om te gaan.
Bijvoorbeeld, geen van de andere antwoorden kon het volgende aan:
a = [1,2,3,4,5]
b = [5,4,3,2,1]
Maar deze wel:
2nd has [5, 4, 3, 2]
both have [1]
1st has [2, 3, 4, 5]
Antwoord 12
dit zou zelfs sneller kunnen zijn dan Marks lijstbegrip:
list(itertools.filterfalse(set(temp2).__contains__, temp1))
Antwoord 13
Hier is een Counterantwoord voor het eenvoudigste geval.
Dit is korter dan degene hierboven die tweerichtingsverschillen uitvoert, omdat het alleen precies doet wat de vraag vraagt: een lijst genereren van wat in de eerste lijst staat, maar niet in de tweede.
from collections import Counter
lst1 = ['One', 'Two', 'Three', 'Four']
lst2 = ['One', 'Two']
c1 = Counter(lst1)
c2 = Counter(lst2)
diff = list((c1 - c2).elements())
Als alternatief, afhankelijk van uw leesbaarheidsvoorkeuren, zorgt het voor een behoorlijke oneliner:
diff = list((Counter(lst1) - Counter(lst2)).elements())
Uitvoer:
['Three', 'Four']
Houd er rekening mee dat u de aanroep list(...)kunt verwijderen als u er gewoon overheen herhaalt.
Omdat deze oplossing tellers gebruikt, worden hoeveelheden correct verwerkt in vergelijking met de vele set-gebaseerde antwoorden. Bijvoorbeeld op deze invoer:
lst1 = ['One', 'Two', 'Two', 'Two', 'Three', 'Three', 'Four']
lst2 = ['One', 'Two']
De uitvoer is:
['Two', 'Two', 'Three', 'Three', 'Four']
Antwoord 14
Hier zijn een paar eenvoudige, orderbehoudendemanieren om twee lijsten met strings te onderscheiden.
Code
Een ongebruikelijke benadering met behulp van pathlib:
import pathlib
temp1 = ["One", "Two", "Three", "Four"]
temp2 = ["One", "Two"]
p = pathlib.Path(*temp1)
r = p.relative_to(*temp2)
list(r.parts)
# ['Three', 'Four']
Dit veronderstelt dat beide lijsten strings bevatten met een equivalent begin. Zie de docsvoor meer details. Let op, het is niet bijzonder snel in vergelijking met ingestelde bewerkingen.
Een eenvoudige implementatie met behulp van itertools.zip_longest:
import itertools as it
[x for x, y in it.zip_longest(temp1, temp2) if x != y]
# ['Three', 'Four']
Antwoord 15
Dit is een andere oplossing:
def diff(a, b):
xa = [i for i in set(a) if i not in b]
xb = [i for i in set(b) if i not in a]
return xa + xb
Antwoord 16
Je zou een naïeve methode kunnen gebruiken als de elementen van de difflist zijn gesorteerd en ingesteld.
list1=[1,2,3,4,5]
list2=[1,2,3]
print list1[len(list2):]
of met native set-methoden:
subset=set(list1).difference(list2)
print subset
import timeit
init = 'temp1 = list(range(100)); temp2 = [i * 2 for i in range(50)]'
print "Naive solution: ", timeit.timeit('temp1[len(temp2):]', init, number = 100000)
print "Native set solution: ", timeit.timeit('set(temp1).difference(temp2)', init, number = 100000)
Naïeve oplossing: 0.0787101593292
Native set-oplossing: 0.998837615564
Antwoord 17
Ik ben een beetje te laat in het spel hiervoor, maar je kunt een vergelijking maken van de prestaties van een aantal van de bovengenoemde code hiermee, twee van de snelste kanshebbers zijn,
list(set(x).symmetric_difference(set(y)))
list(set(x) ^ set(y))
Mijn excuses voor het elementaire coderingsniveau.
import time
import random
from itertools import filterfalse
# 1 - performance (time taken)
# 2 - correctness (answer - 1,4,5,6)
# set performance
performance = 1
numberoftests = 7
def answer(x,y,z):
if z == 0:
start = time.clock()
lists = (str(list(set(x)-set(y))+list(set(y)-set(y))))
times = ("1 = " + str(time.clock() - start))
return (lists,times)
elif z == 1:
start = time.clock()
lists = (str(list(set(x).symmetric_difference(set(y)))))
times = ("2 = " + str(time.clock() - start))
return (lists,times)
elif z == 2:
start = time.clock()
lists = (str(list(set(x) ^ set(y))))
times = ("3 = " + str(time.clock() - start))
return (lists,times)
elif z == 3:
start = time.clock()
lists = (filterfalse(set(y).__contains__, x))
times = ("4 = " + str(time.clock() - start))
return (lists,times)
elif z == 4:
start = time.clock()
lists = (tuple(set(x) - set(y)))
times = ("5 = " + str(time.clock() - start))
return (lists,times)
elif z == 5:
start = time.clock()
lists = ([tt for tt in x if tt not in y])
times = ("6 = " + str(time.clock() - start))
return (lists,times)
else:
start = time.clock()
Xarray = [iDa for iDa in x if iDa not in y]
Yarray = [iDb for iDb in y if iDb not in x]
lists = (str(Xarray + Yarray))
times = ("7 = " + str(time.clock() - start))
return (lists,times)
n = numberoftests
if performance == 2:
a = [1,2,3,4,5]
b = [3,2,6]
for c in range(0,n):
d = answer(a,b,c)
print(d[0])
elif performance == 1:
for tests in range(0,10):
print("Test Number" + str(tests + 1))
a = random.sample(range(1, 900000), 9999)
b = random.sample(range(1, 900000), 9999)
for c in range(0,n):
#if c not in (1,4,5,6):
d = answer(a,b,c)
print(d[1])
Antwoord 18
Als je TypeError: unhashable type: 'list'tegenkomt, moet je lijsten of sets omzetten in tupels, bijvoorbeeld
set(map(tuple, list_of_lists1)).symmetric_difference(set(map(tuple, list_of_lists2)))
Zie ook Een lijst met lijsten vergelijken /sets in python?
Antwoord 19
Stel dat we twee lijsten hebben
list1 = [1, 3, 5, 7, 9]
list2 = [1, 2, 3, 4, 5]
we kunnen aan de bovenstaande twee lijsten zien dat items 1, 3, 5 voorkomen in lijst2 en items 7, 9 niet. Aan de andere kant komen items 1, 3, 5 voor in lijst1 en items 2, 4 niet.
Wat is de beste oplossing om een nieuwe lijst met items 7, 9 en 2, 4 te retourneren?
Alle antwoorden hierboven vinden de oplossing, wat is nu het meest optimaal?
def difference(list1, list2):
new_list = []
for i in list1:
if i not in list2:
new_list.append(i)
for j in list2:
if j not in list1:
new_list.append(j)
return new_list
tegen
def sym_diff(list1, list2):
return list(set(list1).symmetric_difference(set(list2)))
Met timeit kunnen we de resultaten zien
t1 = timeit.Timer("difference(list1, list2)", "from __main__ import difference,
list1, list2")
t2 = timeit.Timer("sym_diff(list1, list2)", "from __main__ import sym_diff,
list1, list2")
print('Using two for loops', t1.timeit(number=100000), 'Milliseconds')
print('Using two for loops', t2.timeit(number=100000), 'Milliseconds')
retouren
[7, 9, 2, 4]
Using two for loops 0.11572412995155901 Milliseconds
Using symmetric_difference 0.11285737506113946 Milliseconds
Process finished with exit code 0
Antwoord 20
éénregelige versie van arulmroplossing
def diff(listA, listB):
return set(listA) - set(listB) | set(listA) -set(listB)
Antwoord 21
als je iets meer wilt zoals een wijzigingenset… zou je Counter kunnen gebruiken
from collections import Counter
def diff(a, b):
""" more verbose than needs to be, for clarity """
ca, cb = Counter(a), Counter(b)
to_add = cb - ca
to_remove = ca - cb
changes = Counter(to_add)
changes.subtract(to_remove)
return changes
lista = ['one', 'three', 'four', 'four', 'one']
listb = ['one', 'two', 'three']
In [127]: diff(lista, listb)
Out[127]: Counter({'two': 1, 'one': -1, 'four': -2})
# in order to go from lista to list b, you need to add a "two", remove a "one", and remove two "four"s
In [128]: diff(listb, lista)
Out[128]: Counter({'four': 2, 'one': 1, 'two': -1})
# in order to go from listb to lista, you must add two "four"s, add a "one", and remove a "two"
Antwoord 22
Ik gebruik liever conversie naar sets en gebruik dan de functie “difference()”. De volledige code is:
temp1 = ['One', 'Two', 'Three', 'Four' ]
temp2 = ['One', 'Two']
set1 = set(temp1)
set2 = set(temp2)
set3 = set1.difference(set2)
temp3 = list(set3)
print(temp3)
Uitvoer:
>>>print(temp3)
['Three', 'Four']
Het is het gemakkelijkst te begrijpen, en als je in de toekomst met grote gegevens werkt, zal het converteren ervan naar sets duplicaten verwijderen als duplicaten niet nodig zijn. Ik hoop dat het helpt 😉
Antwoord 23
We kunnen het snijpunt minus de vereniging van lijsten berekenen:
temp1 = ['One', 'Two', 'Three', 'Four']
temp2 = ['One', 'Two', 'Five']
set(temp1+temp2)-(set(temp1)&set(temp2))
Out: set(['Four', 'Five', 'Three'])
Antwoord 24
Dit kan met één regel worden opgelost.
De vraag krijgt twee lijsten (temp1 en temp2) en geef hun verschil terug in een derde lijst (temp3).
temp3 = list(set(temp1).difference(set(temp2)))
Antwoord 25
Als u alle waarden uit lijst amoet verwijderen, die aanwezig zijn in lijst b.
def list_diff(a, b):
r = []
for i in a:
if i not in b:
r.append(i)
return r
list_diff([1,2,2], [1])
Resultaat: [2,2]
of
def list_diff(a, b):
return [x for x in a if x not in b]
Antwoord 26
Hier is een eenvoudige manier om twee lijsten te onderscheiden (ongeacht de inhoud), u kunt het resultaat krijgen zoals hieronder weergegeven:
>>> from sets import Set
>>>
>>> l1 = ['xvda', False, 'xvdbb', 12, 'xvdbc']
>>> l2 = ['xvda', 'xvdbb', 'xvdbc', 'xvdbd', None]
>>>
>>> Set(l1).symmetric_difference(Set(l2))
Set([False, 'xvdbd', None, 12])
Hopelijk helpt dit.
Antwoord 27
Ik weet dat deze vraag al geweldige antwoorden heeft gekregen, maar ik wil de volgende methode toevoegen met behulp van numpy.
temp1 = ['One', 'Two', 'Three', 'Four']
temp2 = ['One', 'Two']
list(np.setdiff1d(temp1,temp2))
['Four', 'Three'] #Output
Antwoord 28
Hier is een aangepaste versie van het antwoord
van @SuperNova
def get_diff(a: list, b: list) -> list:
return list(set(a) ^ set(b))
Antwoord 29
U kunt door de eerste lijst bladeren en voor elk item dat niet in de tweede lijst staat, maar wel in de eerste lijst, het toevoegen aan de derde lijst. Bijv.:
temp3 = []
for i in temp1:
if i not in temp2:
temp3.append(i)
print(temp3)
Antwoord 30
def diffList(list1, list2): # returns the difference between two lists.
if len(list1) > len(list2):
return (list(set(list1) - set(list2)))
else:
return (list(set(list2) - set(list1)))
bijv. als list1 = [10, 15, 20, 25, 30, 35, 40]en list2 = [25, 40, 35]dan is de geretourneerde lijst output = [10, 20, 30, 15]