파이썬에서 숫자의 목록을 합치십시오

과 같은 숫자 목록이 있으며 두 번째 와 세 번째 등 [1,2,3,4,5...]을 계산 (1+2)/2하고 싶습니다 . 어떻게해야합니까?(2+3)/2(3+4)/2

첫 번째 숫자를 두 번째 숫자와 합산하여 2로 나누고 두 번째 숫자를 세 번째와 합산하고 2로 나누고 싶습니다.

또한 숫자 목록을 어떻게 합칠 수 있습니까?

a = [1, 2, 3, 4, 5, ...]

그렇습니까?

b = sum(a)
print b

하나의 숫자를 얻으려면?

이것은 나를 위해 작동하지 않습니다.

질문 1 : (요소 0 + 요소 1) / 2, (요소 1 + 요소 2) / 2 등을 원합니다.

첫 번째 요소를 제외한 모든 요소 중 하나와 마지막 요소를 제외한 모든 요소 중 하나의 두 가지 목록을 만듭니다. 그런 다음 원하는 평균은 두 목록에서 가져온 각 쌍의 평균입니다. 우리 zip는 두 목록에서 쌍을 취하는 데 사용 합니다.

입력 값이 정수 임에도 불구하고 결과에서 소수를보고 싶다고 가정합니다. 기본적으로 파이썬은 정수 나누기를 수행합니다. 나머지는 버립니다. 사물을 완전히 나누려면 부동 소수점 숫자를 사용해야합니다. 다행스럽게도 int를 float로 나누면 float이 만들어 지므로 2.0제수 대신을 사용 2합니다.

그러므로:

averages = [(x + y) / 2.0 for (x, y) in zip(my_list[:-1], my_list[1:])]

질문 2 :

그 사용은 sum잘 작동합니다. 다음과 같이 작동합니다.

a = range(10)
# [0,1,2,3,4,5,6,7,8,9]
b = sum(a)
print b
# Prints 45

또한 모든 단계에서 변수에 모든 것을 할당 할 필요는 없습니다. print sum(a)잘 작동합니다.

작성한 내용과 작동하지 않는 방식에 대해 더 구체적으로 설명해야합니다.

숫자의 합계 목록 :

sum(list_of_nums)

목록 이해를 사용하여 n 및 n -1의 절반 계산 (패턴이 올바른 경우) :

[(x + (x - 1)) / 2 for x in list_of_nums]

reduce 및 lambdas를 사용하여 ((1 + 2) / 2) + ((2 + 3) / 2) + ... 인접한 요소 합

reduce(lambda x, y: (x + y) / 2, list_of_nums)

질문 2 : 정수 목록을 합치려면 :

a = [2, 3, 5, 8]
sum(a)
# 18
# or you can do:
sum(i for i in a)
# 18

목록에 정수가 문자열로 포함 된 경우 :

a = ['5', '6']
# import Decimal: from decimal import Decimal
sum(Decimal(i) for i in a)

이 방법으로 시도 할 수 있습니다 :

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

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

sum코드 어딘가에 정의되어 있으며 기본 기능을 덮어 쓴 것 같습니다 . 그래서 나는 그것을 삭제하고 문제가 해결되었습니다.

간단 list-comprehension하고 sum:

>> sum(i for i in range(x))/2. #if x = 10 the result will be 22.5

모든 답변은 프로그램적이고 일반적인 접근 방식을 보여주었습니다. 귀하의 경우에 맞는 수학적 접근법을 제안합니다. 긴 목록의 경우 특히 빠를 수 있습니다. 목록이 최대 자연수 목록이기 때문에 작동합니다 n.

자연수가 있다고 가정 해 봅시다 1, 2, 3, ..., 10.

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

sum목록에서이 기능을 사용할 수 있습니다 .

>>> print sum(nat_seq)
55

또한 공식 사용할 수 있습니다 : (여기에 목록의 마지막 요소의 값입니다 당신이 요소를 통해 반복하는을 피할 수 있도록)n*(n+1)/2nnat_seq[-1]

>>> print (nat_seq[-1]*(nat_seq[-1]+1))/2
55

시퀀스를 생성하려면 (1+2)/2, (2+3)/2, ..., (9+10)/2생성기와 수식을 사용할 수 있습니다 (2*k-1)/2.(점을 참고하여 값을 부동 소수점으로 설정). 새 목록을 생성 할 때 첫 번째 요소를 건너 뛰어야합니다.

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

여기에서도 sum해당 목록 의 기능을 사용할 수 있습니다 .

>>> print sum(new_seq)
49.5

그러나 formula를 사용할 수도 (((n*2+1)/2)**2-1)/2있으므로 요소 반복을 피할 수 있습니다.

>>> print (((new_seq[-1]*2+1)/2)**2-1)/2
49.5

이 문제를 해결하는 가장 간단한 방법 :

l =[1,2,3,4,5]
sum=0
for element in l:
    sum+=element
print sum

이 질문은 여기 에 답변 되었습니다

a = [1,2,3,4] sum (a)는 10을 반환합니다

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]

생성기는 이것을 작성하는 쉬운 방법입니다.

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]

초보자를 위해 쉽게 만들자 :-

1. global키워드는 새 로컬 변수를 생성하지 않고 전역 변수 메시지가 주 함수 내에서 할당 할 수 있습니다

    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

이 개념을 그림자 라고합니다

2. 파이썬에서 숫자의 목록을 합치십시오

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()

출력 = 15

은 Using pairwise itertools 요리법 :

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

짧고 간단한

def ave(x,y):
  return (x + y) / 2.0

map(ave, a[:-1], a[1:])

그리고 그 모습은 다음과 같습니다.

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

파이썬이 map두 개 이상의 목록을 처리하는 방식에 약간의 어리 석음이 있기 때문에 목록을 잘라야합니다 a[:-1]. 다음을 사용하면 예상대로 더 잘 작동합니다 itertools.imap.

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

너무 많은 솔루션이지만 여전히 가장 좋아하는 솔루션이 없습니다.

>>> import numpy as np
>>> arr = np.array([1,2,3,4,5])

numpy 배열은 배열을 숫자와 같이 취급 할 수 있다는 점을 제외하고 (이 경우에는) 목록과 크게 다르지 않습니다.

>>> ( arr[:-1] + arr[1:] ) / 2.0
[ 1.5  2.5  3.5  4.5]

끝난!

설명

팬시 인덱스는 이것을 의미합니다 : [1:]1에서 끝까지의 모든 요소를 ​​포함하므로 (요소 0을 생략) [:-1]마지막 요소를 제외한 모든 요소입니다.

>>> arr[:-1]
array([1, 2, 3, 4])
>>> arr[1:]
array([2, 3, 4, 5])

따라서이 두 개를 추가하면 elemens (1 + 2), (2 + 3) 등으로 구성된 배열이 제공됩니다. 파이썬은 당신이 정수 만 사용하고 둥근 정수 결과를 생성한다고 믿기 때문에으로 나누지 2.0않습니다 2.

numpy 사용의 이점

Numpy는 숫자 목록을 둘러싼 루프보다 훨씬 빠릅니다. 목록의 크기에 따라 몇 배 더 빠릅니다. 또한 코드가 훨씬 적고 적어도 나에게는 읽기 쉽습니다. 나는 모든 수의 그룹에 numpy를 사용하는 습관을 없애려고 노력하고 있으며, 그렇지 않으면 다른 루프와 루프 내 루프에 대해 크게 개선되었습니다.

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

while루프를 사용 하여 결과를 얻습니다.

i = 0
while i < len(a)-1:
   result = (a[i]+a[i+1])/2
   print result
   i +=1

목록의 요소를 반복하고 다음과 같이 총계를 업데이트하십시오.

def sum(a):
    total = 0
    index = 0
    while index < len(a):
        total = total + a[index]
        index = index + 1
    return total

Karl Knechtel 덕분에 귀하의 질문을 이해할 수있었습니다. 내 해석 :

1. 요소 i 및 i + 1의 평균을 가진 새 목록을 원합니다.
2. 목록의 각 요소를 합치려고합니다.

익명 함수 (일명 Lambda 함수)를 사용하는 첫 번째 질문 :

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

익명 함수 (일명 Lambda 함수)를 사용하는 두 번째 질문 :

p = lambda l: l[0] + p(l[1:]) if l!=[] else 0

두 질문 모두 한 줄의 코드로 결합되었습니다.

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

가장 적합한 것을 사용하십시오

재귀를 사용하여 동일한 작업을 수행 할 수도 있습니다.

파이썬 스 니펫 :

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

목록 이해력을 사용해보십시오. 다음과 같은 것 :

new_list = [(old_list[i] + old_list[i+1])/2 for i in range(len(old_list-1))]

itertools의 정신으로. pairwise 레시피에서 영감을 얻습니다.

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

예 :

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

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)

간단한 방법은 iter_tools 순열을 사용하는 것입니다

# 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)

결과는 다음과 같습니다.

[(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)]

1, 2, 7을 의미하는 순서는 2, 1, 7 및 7, 1, 2로 표시됩니다. 세트를 사용하여이를 줄일 수 있습니다.

Python 3.8에서는 새로운 할당 연산자를 사용할 수 있습니다

>>> 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는 목록 의 이전 값에 대한 실행 참조 이므로 목록의 첫 번째 요소로 초기화되고 반복 은 목록 의 나머지 부분 에서 발생하며 a각 반복에서 사용 된 후에 업데이트 됩니다.

명시 적 반복자는를 사용하여 목록의 복사본을 만들 필요가 없도록하는 데 사용 my_list[1:]됩니다.

다음을 시도하십시오-

mylist = [1, 2, 3, 4]   

def add(mylist):
    total = 0
    for i in mylist:
        total += i
    return total

result = add(mylist)
print("sum = ", result)