Jumlahkan daftar angka dengan Python

Saya memiliki daftar angka seperti [1,2,3,4,5...], dan saya ingin menghitung (1+2)/2dan untuk yang kedua, (2+3)/2dan yang ketiga (3+4)/2,, dan seterusnya. Bagaimana saya bisa melakukan itu?

Saya ingin menjumlahkan angka pertama dengan yang kedua dan membaginya dengan 2, kemudian menjumlahkan yang kedua dengan yang ketiga dan membaginya dengan 2, dan seterusnya.

Juga, bagaimana saya bisa menjumlahkan daftar angka?

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

Apakah itu:

b = sum(a)
print b

untuk mendapatkan satu nomor?

Ini tidak berhasil untuk saya.

Pertanyaan 1: Jadi Anda mau (elemen 0 + elemen 1) / 2, (elemen 1 + elemen 2) / 2, ... dll.

Kami membuat dua daftar: satu dari setiap elemen kecuali yang pertama, dan satu dari setiap elemen kecuali yang terakhir. Maka rata-rata yang kita inginkan adalah rata-rata dari setiap pasangan yang diambil dari dua daftar. Kami menggunakan zipuntuk mengambil pasangan dari dua daftar.

Saya berasumsi Anda ingin melihat desimal dalam hasilnya, meskipun nilai input Anda bilangan bulat. Secara default, Python melakukan pembagian integer: ia membuang sisanya. Untuk membagi semuanya melalui semua, kita perlu menggunakan angka floating-point. Untungnya, membagi sebuah int dengan float akan menghasilkan float, jadi kita gunakan saja 2.0untuk pembagi kita 2.

Jadi:

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

Pertanyaan 2:

Penggunaan itu sumharus bekerja dengan baik. Karya-karya berikut:

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

Selain itu, Anda tidak perlu menetapkan semuanya ke variabel di setiap langkah di sepanjang jalan. print sum(a)berfungsi dengan baik.

Anda harus lebih spesifik tentang apa yang Anda tulis dan bagaimana cara kerjanya.

Jumlahkan daftar angka:

sum(list_of_nums)

Menghitung setengah dari n dan n - 1 (jika saya memiliki pola yang benar), menggunakan daftar pemahaman :

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

Jumlah elemen yang berdekatan, misalnya ((1 + 2) / 2) + ((2 + 3) / 2) + ... menggunakan pengurangan dan lambda

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

Pertanyaan 2: Untuk menjumlahkan daftar bilangan bulat:

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

Jika daftar berisi bilangan bulat sebagai string:

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

Anda dapat mencoba cara ini:

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

Tampaknya sumtelah didefinisikan dalam kode di suatu tempat dan menimpa fungsi default. Jadi saya menghapusnya dan masalah terpecahkan.

Menggunakan yang sederhana list-comprehensiondan yang sum:

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

Semua jawaban memang menunjukkan pendekatan programatik dan umum. Saya menyarankan pendekatan matematis yang spesifik untuk kasus Anda. Ini bisa lebih cepat khususnya untuk daftar panjang. Ini berfungsi karena daftar Anda adalah daftar bilangan asli hingga n:

Anggaplah kita memiliki bilangan asli 1, 2, 3, ..., 10:

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

Anda dapat menggunakan sumfungsi pada daftar:

>>> print sum(nat_seq)
55

Anda juga dapat menggunakan rumus di n*(n+1)/2mana nnilai elemen terakhir dalam daftar (di sini nat_seq[-1]:), sehingga Anda menghindari iterasi pada elemen:

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

Untuk menghasilkan urutan, (1+2)/2, (2+3)/2, ..., (9+10)/2Anda dapat menggunakan generator dan rumus (2*k-1)/2.(perhatikan titik untuk membuat nilai floating point). Anda harus melewati elemen pertama saat membuat daftar baru:

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

Di sini juga, Anda dapat menggunakan sumfungsi pada daftar itu:

>>> print sum(new_seq)
49.5

Tapi Anda juga bisa menggunakan rumus (((n*2+1)/2)**2-1)/2, jadi Anda bisa menghindari iterasi pada elemen:

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

Cara paling sederhana untuk menyelesaikan masalah ini:

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

Pertanyaan ini telah dijawab di sini

a = [1,2,3,4] jumlah (a) menghasilkan 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]

Generator adalah cara mudah untuk menulis ini:

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]

Mari kita membuatnya mudah bagi Pemula: -

1. Kata globalkunci akan memungkinkan pesan variabel global ditugaskan dalam fungsi utama tanpa menghasilkan variabel lokal baru

    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

Konsep ini disebut Shadowing

2. Jumlahkan daftar angka dengan 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()

Output = 15

Menggunakan pairwise resep 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) )

Pendek dan sederhana:

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

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

Dan begini tampilannya:

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

Karena beberapa kebodohan dalam cara Python menangani maplebih dari dua daftar, Anda harus memotong daftar a[:-1],. Ini berfungsi lebih seperti yang Anda harapkan jika Anda menggunakan 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]

Banyak sekali solusi, tetapi favorit saya masih belum ada:

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

array numpy tidak terlalu berbeda dari daftar (dalam kasus penggunaan ini), kecuali bahwa Anda dapat memperlakukan array seperti angka:

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

Selesai!

penjelasan

Indeks mewah berarti ini: [1:]mencakup semua elemen dari 1 hingga akhir (sehingga menghilangkan elemen 0), dan [:-1]semuanya adalah elemen kecuali yang terakhir:

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

Jadi menambahkan keduanya memberi Anda array yang terdiri dari elemens (1 + 2), (2 + 3) dan seterusnya. Bukannya saya membaginya 2.0, bukan 2karena kalau tidak Python percaya bahwa Anda hanya menggunakan bilangan bulat dan menghasilkan hasil bilangan bulat bulat.

Keuntungan menggunakan numpy

Numpy bisa jauh lebih cepat daripada loop di sekitar daftar angka. Tergantung pada seberapa besar daftar Anda, beberapa urutan besarnya lebih cepat. Juga, ini kode yang jauh lebih sedikit, dan setidaknya bagi saya, lebih mudah dibaca. Saya mencoba membuat kebiasaan keluar dari menggunakan numpy untuk semua kelompok angka, dan ini merupakan peningkatan besar untuk semua loop dan loop-dalam-loop saya kalau tidak harus membuat.

Saya hanya menggunakan lambda dengan peta ()

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

Saya menggunakan whileloop untuk mendapatkan hasilnya:

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

Ulangi elemen dalam daftar dan perbarui total seperti ini:

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

Terima kasih kepada Karl Knechtel saya bisa memahami pertanyaan Anda. Interpretasi saya:

1. Anda ingin daftar baru dengan rata-rata elemen i dan i +1.
2. Anda ingin menjumlahkan setiap elemen dalam daftar.

Pertanyaan pertama menggunakan fungsi anonim (alias fungsi 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

Pertanyaan kedua juga menggunakan fungsi anonim (alias. Fungsi Lambda):

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

Kedua pertanyaan tersebut digabungkan dalam satu baris kode:

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

gunakan yang sesuai dengan kebutuhan Anda

Anda juga dapat melakukan hal yang sama menggunakan rekursi:

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

Coba gunakan pemahaman daftar. Sesuatu seperti:

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

Dalam semangat itertools. Inspirasi dari resep berpasangan.

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

Contoh:

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

Cara sederhana adalah dengan menggunakan permutasi 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)

Hasilnya adalah:

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

Perhatikan bahwa masalah pesanan - artinya 1, 2, 7 juga ditampilkan sebagai 2, 1, 7 dan 7, 1, 2. Anda dapat menguranginya dengan menggunakan satu set.

Dalam Python 3.8, operator penugasan baru dapat digunakan

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

aadalah referensi yang berjalan ke nilai sebelumnya dalam daftar, oleh karena itu diinisialisasi ke elemen pertama dari daftar dan iterasi terjadi selama sisa daftar, memperbarui asetelah digunakan di setiap iterasi.

Iterator eksplisit digunakan untuk menghindari keharusan membuat salinan daftar menggunakan my_list[1:].

Coba yang berikut -

mylist = [1, 2, 3, 4]   

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

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