Tổng hợp danh sách các số trong Python

Tôi có một danh sách các số như [1,2,3,4,5...], và tôi muốn tính toán (1+2)/2và cho lần thứ hai, (2+3)/2và thứ ba, (3+4)/2v.v. Làm thế nào tôi có thể làm điều đó?

Tôi muốn tính tổng số thứ nhất với số thứ hai và chia cho 2, sau đó tổng số thứ hai với số thứ ba và chia cho 2, v.v.

Ngoài ra, làm thế nào tôi có thể tổng hợp một danh sách các số?

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

Là nó:

b = sum(a)
print b

để có được một số?

Điều này không làm việc cho tôi.

Câu 1: Vì vậy, bạn muốn (phần tử 0 + phần tử 1) / 2, (phần tử 1 + phần tử 2) / 2, ... vv

Chúng tôi lập hai danh sách: một trong mọi yếu tố ngoại trừ đầu tiên và một trong mọi yếu tố ngoại trừ cuối cùng. Sau đó, trung bình chúng tôi muốn là trung bình của mỗi cặp được lấy từ hai danh sách. Chúng tôi sử dụng zipđể lấy cặp từ hai danh sách.

Tôi giả sử bạn muốn xem số thập phân trong kết quả, mặc dù giá trị đầu vào của bạn là số nguyên. Theo mặc định, Python thực hiện phân chia số nguyên: nó loại bỏ phần còn lại. Để phân chia mọi thứ theo mọi cách, chúng ta cần sử dụng các số dấu phẩy động. May mắn thay, chia một int cho một float sẽ tạo ra một float, vì vậy chúng ta chỉ sử dụng 2.0cho ước số của chúng ta thay vì 2.

Như vậy:

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

Câu hỏi 2:

Mà sử dụng sumnên hoạt động tốt. Các công việc sau đây:

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

Ngoài ra, bạn không cần chỉ định mọi thứ cho một biến ở mỗi bước trên đường đi. print sum(a)hoạt động tốt

Bạn sẽ phải cụ thể hơn về chính xác những gì bạn đã viết và cách nó không hoạt động.

Danh sách tổng hợp các số:

sum(list_of_nums)

Tính một nửa của n và n - 1 (nếu tôi có mẫu đúng), sử dụng cách hiểu danh sách :

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

Tổng các phần tử liền kề, ví dụ ((1 + 2) / 2) + ((2 + 3) / 2) + ... bằng cách sử dụng giảm và lambdas

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

Câu 2: Để tổng hợp danh sách các số nguyên:

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

Nếu danh sách chứa số nguyên dưới dạng chuỗi:

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

Bạn có thể thử theo cách này:

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

Có vẻ như sumđã được xác định trong mã ở đâu đó và ghi đè hàm mặc định. Vì vậy, tôi đã xóa nó và vấn đề đã được giải quyết.

Sử dụng đơn giản list-comprehensionvà sum:

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

Tất cả các câu trả lời đã cho thấy một cách tiếp cận có lập trình và chung. Tôi đề nghị một phương pháp toán học cụ thể cho trường hợp của bạn. Nó có thể nhanh hơn đặc biệt cho các danh sách dài. Nó hoạt động vì danh sách của bạn là một danh sách các số tự nhiên lên đến n:

Giả sử chúng ta có các số tự nhiên 1, 2, 3, ..., 10:

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

Bạn có thể sử dụng sumchức năng trong danh sách:

>>> print sum(nat_seq)
55

Bạn cũng có thể sử dụng công thức n*(n+1)/2trong đó ngiá trị của phần tử cuối cùng trong danh sách (ở đây nat_seq[-1]:), vì vậy bạn tránh lặp lại các phần tử:

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

Để tạo chuỗi, (1+2)/2, (2+3)/2, ..., (9+10)/2bạn có thể sử dụng trình tạo và công thức (2*k-1)/2.(lưu ý dấu chấm để tạo các giá trị dấu phẩy động). Bạn phải bỏ qua phần tử đầu tiên khi tạo danh sách mới:

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

Ở đây cũng vậy, bạn có thể sử dụng sumchức năng trong danh sách đó:

>>> print sum(new_seq)
49.5

Nhưng bạn cũng có thể sử dụng công thức (((n*2+1)/2)**2-1)/2, vì vậy bạn có thể tránh lặp lại các phần tử:

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

Cách đơn giản nhất để giải quyết vấn đề này:

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

Câu hỏi này đã được trả lời ở đây

a = [1,2,3,4] tổng (a) trả về 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]

Máy phát điện là một cách dễ dàng để viết này:

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]

Hãy để chúng tôi làm cho nó dễ dàng cho người mới bắt đầu: -

1. Các globaltừ khóa sẽ cho phép nhắn biến toàn cầu được giao trong phạm vi chức năng chính mà không tạo ra một biến địa phương mới

    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

Khái niệm này được gọi là Shadowing

2. Tổng hợp danh sách các số trong 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()

Đầu ra = 15

Sử dụng pairwise công thức 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) )

Ngắn gọn và đơn giản:

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

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

Và đây là giao diện của nó:

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

Do một số sự ngu ngốc trong cách Python xử lý maphơn hai danh sách, bạn phải cắt bớt danh sách , a[:-1]. Nó hoạt động nhiều hơn bạn mong đợi nếu bạn sử dụng 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]

Rất nhiều giải pháp, nhưng yêu thích của tôi vẫn còn thiếu:

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

một mảng numpy không quá khác biệt với một danh sách (trong trường hợp sử dụng này), ngoại trừ việc bạn có thể coi các mảng như số:

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

Làm xong!

giải trình

Các chỉ số ưa thích có nghĩa là: [1:]bao gồm tất cả các phần tử từ 1 đến cuối (do đó bỏ qua phần tử 0) và [:-1]là tất cả các phần tử ngoại trừ phần tử cuối cùng:

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

Vì vậy, việc thêm hai cái đó cung cấp cho bạn một mảng bao gồm elemens (1 + 2), (2 + 3), v.v. Không phải tôi đang chia cho 2.0, không phải 2vì Python khác tin rằng bạn chỉ sử dụng số nguyên và tạo ra kết quả số nguyên tròn.

lợi thế của việc sử dụng numpy

NumPy có thể nhiều nhanh hơn so với vòng xung quanh danh sách các số. Tùy thuộc vào mức độ lớn của danh sách của bạn, một số đơn đặt hàng có cường độ nhanh hơn. Ngoài ra, nó ít mã hơn rất nhiều, và ít nhất với tôi, nó dễ đọc hơn. Tôi đang cố gắng tạo thói quen sử dụng numpy cho tất cả các nhóm số và đó là một cải tiến lớn đối với tất cả các vòng lặp và vòng lặp trong vòng mà tôi sẽ phải thực hiện.

Tôi chỉ sử dụng lambda với 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

Tôi sử dụng một whilevòng lặp để có được kết quả:

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

Lặp lại các yếu tố trong danh sách và cập nhật tổng số như thế này:

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

Nhờ Karl Knechtel tôi đã có thể hiểu câu hỏi của bạn. Lời giải thích của tôi:

1. Bạn muốn có một danh sách mới với mức trung bình của phần tử i và i + 1.
2. Bạn muốn tổng hợp từng yếu tố trong danh sách.

Câu hỏi đầu tiên sử dụng chức năng ẩn danh (còn gọi là chức năng 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

Câu hỏi thứ hai cũng sử dụng chức năng ẩn danh (còn gọi là chức năng Lambda):

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

Cả hai câu hỏi kết hợp trong một dòng mã:

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

sử dụng một trong những phù hợp nhất với nhu cầu của bạn

Bạn cũng có thể làm tương tự bằng cách sử dụng đệ quy:

Đoạn mã Python:

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

Hãy thử sử dụng một danh sách hiểu. Cái gì đó như:

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

Trong tinh thần của itertools. Cảm hứng từ công thức cặp.

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

Ví dụ:

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

Một cách đơn giản là sử dụng hoán vị 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)

Kết quả là:

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

Lưu ý rằng các vấn đề về thứ tự - có nghĩa là 1, 2, 7 cũng được hiển thị là 2, 1, 7 và 7, 1, 2. Bạn có thể giảm điều này bằng cách sử dụng một bộ.

Trong Python 3.8, toán tử gán mới có thể được sử dụng

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

alà một tham chiếu đang chạy đến giá trị trước đó trong danh sách, do đó nó được khởi tạo thành phần tử đầu tiên của danh sách và việc lặp lại xảy ra so với phần còn lại của danh sách, cập nhật asau khi được sử dụng trong mỗi lần lặp.

Một trình vòng lặp rõ ràng được sử dụng để tránh cần phải tạo một bản sao của danh sách bằng cách sử dụng my_list[1:].

Hãy thử như sau -

mylist = [1, 2, 3, 4]   

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

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