Ik heb een lijst met getallen zoals [1,2,3,4,5...]
, en ik wil (1+2)/2
en voor de tweede, (2+3)/2
en de derde,
(3+4)/2
, enzovoort. Hoe kan ik dat doen?
Ik wil het eerste getal bij het tweede optellen en delen door 2, dan het tweede optellen bij het derde en delen door 2, enzovoort.
Hoe kan ik ook een lijst met getallen optellen?
a = [1, 2, 3, 4, 5, ...]
Is het:
b = sum(a)
print b
om één nummer te krijgen?
Dit werkt niet voor mij.
Antwoord 1, autoriteit 100%
Vraag 1: Dus je wilt (element 0 + element 1) / 2, (element 1 + element 2) / 2, … etc.
We maken twee lijsten: één van elk element behalve het eerste, en één van elk element behalve het laatste. Dan zijn de gemiddelden die we willen de gemiddelden van elk paar uit de twee lijsten. We gebruiken zip
om paren uit twee lijsten te halen.
Ik neem aan dat je decimalen in het resultaat wilt zien, ook al zijn je invoerwaarden gehele getallen. Python doet standaard deling op gehele getallen: het negeert de rest. Om dingen helemaal door te delen, moeten we getallen met drijvende komma gebruiken. Gelukkig levert het delen van een int door een float een float op, dus gebruiken we gewoon 2.0
voor onze deler in plaats van 2
.
Dus:
averages = [(x + y) / 2.0 for (x, y) in zip(my_list[:-1], my_list[1:])]
Vraag 2:
Dat gebruik van sum
zou goed moeten werken. De volgende werken:
a = range(10)
# [0,1,2,3,4,5,6,7,8,9]
b = sum(a)
print b
# Prints 45
Bovendien hoeft u niet bij elke stap alles aan een variabele toe te wijzen. print sum(a)
werkt prima.
Je zult specifieker moeten zijn over wat je precies hebt geschreven en hoe het niet werkt.
Antwoord 2, autoriteit 43%
Somlijst van getallen:
sum(list_of_nums)
De helft van n en n – 1 berekenen (als ik het patroon correct heb), met behulp van een begrip van de lijst:
[(x + (x - 1)) / 2 for x in list_of_nums]
Stel aangrenzende elementen bij elkaar op, bijv. ((1 + 2) / 2) + ((2 + 3) / 2) + … met behulp van verminderenen lambda’s
reduce(lambda x, y: (x + y) / 2, list_of_nums)
Antwoord 3, autoriteit 26%
Vraag 2:
Om een lijst met gehele getallen op te tellen:
a = [2, 3, 5, 8]
sum(a)
# 18
# or you can do:
sum(i for i in a)
# 18
Als de lijst gehele getallen als strings bevat:
a = ['5', '6']
# import Decimal: from decimal import Decimal
sum(Decimal(i) for i in a)
Antwoord 4, autoriteit 12%
Je kunt het op deze manier proberen:
a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
sm = sum(a[0:len(a)]) # Sum of 'a' from 0 index to 9 index. sum(a) == sum(a[0:len(a)]
print(sm) # Python 3
print sm # Python 2
Antwoord 5, autoriteit 9%
>>> a = range(10)
>>> sum(a)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'int' object is not callable
>>> del sum
>>> sum(a)
45
Het lijkt erop dat sum
ergens in de code is gedefinieerd en de standaardfunctie overschrijft. Dus ik heb het verwijderd en het probleem was opgelost.
Antwoord 6, autoriteit 5%
Een eenvoudig list-comprehension
en de sum
gebruiken:
>> sum(i for i in range(x))/2. #if x = 10 the result will be 22.5
Antwoord 7, autoriteit 5%
Alle antwoorden lieten een programmatische en algemene benadering zien. Ik stel een wiskundige benadering voor die specifiek is voor uw geval. Vooral bij lange lijsten kan het sneller. Het werkt omdat uw lijst een lijst is met natuurlijke getallen tot n
:
Laten we aannemen dat we de natuurlijke getallen 1, 2, 3, ..., 10
hebben:
>>> nat_seq = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
U kunt de functie sum
gebruiken in een lijst:
>>> print sum(nat_seq)
55
Je kunt ook de formule n*(n+1)/2
gebruiken waarbij n
de waarde is van het laatste element in de lijst (hier: nat_seq[-1]
), zodat je herhalingen over elementen vermijdt:
>>> print (nat_seq[-1]*(nat_seq[-1]+1))/2
55
Om de reeks (1+2)/2, (2+3)/2, ..., (9+10)/2
te genereren, kun je een generator gebruiken en de formule (2*k-1)/2.
(let op de punt om de waarden zwevende punten te maken). U moet het eerste element overslaan bij het genereren van de nieuwe lijst:
>>> new_seq = [(2*k-1)/2. for k in nat_seq[1:]]
>>> print new_seq
[1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, 8.5, 9.5]
Ook hier kun je de functie sum
op die lijst gebruiken:
>>> print sum(new_seq)
49.5
Maar u kunt ook de formule (((n*2+1)/2)**2-1)/2
gebruiken, zodat u herhalingen over elementen kunt voorkomen:
>>> print (((new_seq[-1]*2+1)/2)**2-1)/2
49.5
Antwoord 8, autoriteit 3%
Deze vraag is hier
beantwoord
a = [1,2,3,4]
sum(a)
som(a) geeft 10 terug
Antwoord 9, autoriteit 2%
De eenvoudigste manier om dit probleem op te lossen:
l =[1,2,3,4,5]
sum=0
for element in l:
sum+=element
print sum
Antwoord 10, autoriteit 2%
Zoveel oplossingen, maar mijn favoriet ontbreekt nog:
>>> import numpy as np
>>> arr = np.array([1,2,3,4,5])
een numpy-array verschilt niet veel van een lijst (in dit geval), behalve dat je arrays als getallen kunt behandelen:
>>> ( arr[:-1] + arr[1:] ) / 2.0
[ 1.5 2.5 3.5 4.5]
Klaar!
uitleg
De mooie indices betekenen dit: [1:]
bevat alle elementen van 1 tot het einde (dus laat element 0 weg), en [:-1]
zijn allemaal elementen behalve de laatste:
>>> arr[:-1]
array([1, 2, 3, 4])
>>> arr[1:]
array([2, 3, 4, 5])
Dus als je die twee toevoegt, krijg je een array die bestaat uit elementen (1+2), (2+3) enzovoort.
Merk op dat ik deel door 2.0
, niet door 2
omdat Python anders gelooft dat je alleen gehele getallen gebruikt en afgeronde gehele getallen oplevert.
voordeel van numpy
Numpy kan veelsneller zijn dan lussen rond lijsten met getallen. Afhankelijk van hoe groot uw lijst is, kunnen enkele ordes van grootte sneller zijn. Het is ook veel minder code, en in ieder geval voor mij is het gemakkelijker te lezen.
Ik probeer een gewoonte te maken van het gebruik van numpy voor alle groepen getallen, en het is een enorme verbetering voor alle lussen en lussen-in-lussen die ik anders had moeten schrijven.
Antwoord 11
import numpy as np
x = [1,2,3,4,5]
[(np.mean((x[i],x[i+1]))) for i in range(len(x)-1)]
# [1.5, 2.5, 3.5, 4.5]
Antwoord 12
Generatoren zijn een gemakkelijke manier om dit te schrijven:
from __future__ import division
# ^- so that 3/2 is 1.5 not 1
def averages( lst ):
it = iter(lst) # Get a iterator over the list
first = next(it)
for item in it:
yield (first+item)/2
first = item
print list(averages(range(1,11)))
# [1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, 8.5, 9.5]
Antwoord 13
Laten we het gemakkelijk maken voor beginners: –
- De
global
Trefwoord kan het globale variabele bericht binnen de hoofdfunctie worden toegewezen zonder een nieuwe lokale variabele te produceren
message = "This is a global!" def main(): global message message = "This is a local" print(message) main() # outputs "This is a local" - From the Function call print(message) # outputs "This is a local" - From the Outer scope
Dit concept wordt schaduwen
- Sommeert een lijst met nummers in Python
nums = [1, 2, 3, 4, 5] var = 0 def sums(): for num in nums: global var var = var + num print(var) if __name__ == '__main__': sums()
Uitgangen = 15
Antwoord 14
Gebruik van de pairwise
itertools recept :
import itertools
def pairwise(iterable):
"s -> (s0,s1), (s1,s2), (s2, s3), ..."
a, b = itertools.tee(iterable)
next(b, None)
return itertools.izip(a, b)
def pair_averages(seq):
return ( (a+b)/2 for a, b in pairwise(seq) )
Antwoord 15
Kort en eenvoudig:
def ave(x,y):
return (x + y) / 2.0
map(ave, a[:-1], a[1:])
En zo ziet het eruit:
>>> a = range(10)
>>> map(ave, a[:-1], a[1:])
[0.5, 1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, 8.5]
Vanwege een domheid in hoe Python een map
over twee lijsten afhandelt, moet je de lijst, a[:-1]
, afkappen. Het werkt meer zoals je zou verwachten als je itertools.imap
gebruikt:
>>> import itertools
>>> itertools.imap(ave, a, a[1:])
<itertools.imap object at 0x1005c3990>
>>> list(_)
[0.5, 1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, 8.5]
Antwoord 16
In Python 3.8 kan de nieuwe toewijzingsoperator worden gebruikt
>>> my_list = [1, 2, 3, 4, 5]
>>> itr = iter(my_list)
>>> a = next(itr)
>>> [(a + (a:=x))/2 for x in itr]
[1.5, 2.5, 3.5, 4.5]
a
is een lopende verwijzing naar de vorigewaarde in de lijst, daarom wordt het geïnitialiseerd naar het eerste element van de lijst en vindt de iteratie plaats over de restvan de lijst, waarbij a
wordt bijgewerkt nadat deze in elke iteratie is gebruikt.
Er wordt een expliciete iterator gebruikt om te voorkomen dat een kopie van de lijst moet worden gemaakt met my_list[1:]
.
Antwoord 17
U kunt hetzelfde ook doen met recursie:
Python-fragment:
def sumOfArray(arr, startIndex):
size = len(arr)
if size == startIndex: # To Check empty list
return 0
elif startIndex == (size - 1): # To Check Last Value
return arr[startIndex]
else:
return arr[startIndex] + sumOfArray(arr, startIndex + 1)
print(sumOfArray([1,2,3,4,5], 0))
Antwoord 18
Ik gebruik een while
lus om het resultaat te krijgen:
i = 0
while i < len(a)-1:
result = (a[i]+a[i+1])/2
print result
i +=1
Antwoord 19
Loop door middel van elementen in de lijst en het actualiseren van de totale als volgt uit:
def sum(a):
total = 0
index = 0
while index < len(a):
total = total + a[index]
index = index + 1
return total
Antwoord 20
Dankzij KARL Knechtel Ik was in staat om uw vraag te begrijpen. Mijn interpretatie:
- U wilt een nieuwe lijst met het gemiddelde van het element I en I + 1.
- U wilt elk element in de lijst samenvatten.
Eerste vraag met behulp van anonieme functie (aka Lambda functie.):
s = lambda l: [(l[0]+l[1])/2.] + s(l[1:]) if len(l)>1 else [] #assuming you want result as float
s = lambda l: [(l[0]+l[1])//2] + s(l[1:]) if len(l)>1 else [] #assuming you want floor result
Second vraag ook met behulp van anonieme functie (aka Lambda functie.):
p = lambda l: l[0] + p(l[1:]) if l!=[] else 0
zowel vragen gecombineerd in een enkele regel code:
s = lambda l: (l[0]+l[1])/2. + s(l[1:]) if len(l)>1 else 0 #assuming you want result as float
s = lambda l: (l[0]+l[1])/2. + s(l[1:]) if len(l)>1 else 0 #assuming you want floor result
gebruik degene die het beste bij u past
Antwoord 21
Probeer een lijstbegrip te gebruiken. Iets als:
new_list = [(old_list[i] + old_list[i+1])/2 for i in range(len(old_list-1))]
Antwoord 22
In de geest van itertools. Inspiratie uit het paarsgewijs recept.
from itertools import tee, izip
def average(iterable):
"s -> (s0,s1)/2.0, (s1,s2)/2.0, ..."
a, b = tee(iterable)
next(b, None)
return ((x+y)/2.0 for x, y in izip(a, b))
Voorbeelden:
>>>list(average([1,2,3,4,5]))
[1.5, 2.5, 3.5, 4.5]
>>>list(average([1,20,31,45,56,0,0]))
[10.5, 25.5, 38.0, 50.5, 28.0, 0.0]
>>>list(average(average([1,2,3,4,5])))
[2.0, 3.0, 4.0]
Antwoord 23
Ik zou gewoon een lambda gebruiken met map()
a = [1,2,3,4,5,6,7,8,9,10]
b = map(lambda x, y: (x+y)/2.0, fib[:-1], fib[1:])
print b
Antwoord 24
n = int(input("Enter the length of array: "))
list1 = []
for i in range(n):
list1.append(int(input("Enter numbers: ")))
print("User inputs are", list1)
list2 = []
for j in range(0, n-1):
list2.append((list1[j]+list1[j+1])/2)
print("result = ", list2)
Antwoord 25
Een eenvoudige manier is om de iter_tools permutatie te gebruiken
# If you are given a list
numList = [1,2,3,4,5,6,7]
# and you are asked to find the number of three sums that add to a particular number
target = 10
# How you could come up with the answer?
from itertools import permutations
good_permutations = []
for p in permutations(numList, 3):
if sum(p) == target:
good_permutations.append(p)
print(good_permutations)
Het resultaat is:
[(1, 2, 7), (1, 3, 6), (1, 4, 5), (1, 5, 4), (1, 6, 3), (1, 7, 2), (2, 1, 7), (2, 3,
5), (2, 5, 3), (2, 7, 1), (3, 1, 6), (3, 2, 5), (3, 5, 2), (3, 6, 1), (4, 1, 5), (4,
5, 1), (5, 1, 4), (5, 2, 3), (5, 3, 2), (5, 4, 1), (6, 1, 3), (6, 3, 1), (7, 1, 2),
(7, 2, 1)]
Houd er rekening mee dat de volgorde belangrijk is – wat betekent dat 1, 2, 7 ook wordt weergegeven als 2, 1, 7 en 7, 1, 2. Je kunt dit verminderen door een set te gebruiken.
Antwoord 26
Probeer het volgende –
mylist = [1, 2, 3, 4]
def add(mylist):
total = 0
for i in mylist:
total += i
return total
result = add(mylist)
print("sum = ", result)