Stel een lijst met getallen op in Python

Ik heb een lijst met getallen zoals [1,2,3,4,5...], en ik wil (1+2)/2en voor de tweede, (2+3)/2en 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 zipom 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.0voor 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 sumzou 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 sumergens 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-comprehensionen de sumgebruiken:

>> 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, ..., 10hebben:

>>> nat_seq = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

U kunt de functie sumgebruiken in een lijst:

>>> print sum(nat_seq)
55

Je kunt ook de formule n*(n+1)/2gebruiken waarbij nde 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)/2te 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 sumop die lijst gebruiken:

>>> print sum(new_seq)
49.5

Maar u kunt ook de formule (((n*2+1)/2)**2-1)/2gebruiken, 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 2omdat 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: –

  1. De globalTrefwoord 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

  1. 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 pairwiseitertools 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 mapover twee lijsten afhandelt, moet je de lijst, a[:-1], afkappen. Het werkt meer zoals je zou verwachten als je itertools.imapgebruikt:

>>> 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]

ais 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 awordt 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 whilelus 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:

  1. U wilt een nieuwe lijst met het gemiddelde van het element I en I + 1.
  2. 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)

Other episodes