Bagaimana cara mengalikan setiap elemen dalam daftar dengan angka?

Saya punya daftar:

my_list = [1, 2, 3, 4, 5]

Bagaimana cara mengalikan setiap elemen my_listdengan 5? Outputnya harus:

[5, 10, 15, 20, 25]

Anda bisa menggunakan pemahaman daftar:

my_list = [1, 2, 3, 4, 5]
my_new_list = [i * 5 for i in my_list]

>>> print(my_new_list)
[5, 10, 15, 20, 25]

Perhatikan bahwa pemahaman daftar umumnya merupakan cara yang lebih efisien untuk melakukan forperulangan:

my_new_list = []
for i in my_list:
    my_new_list.append(i * 5)

>>> print(my_new_list)
[5, 10, 15, 20, 25]

Sebagai alternatif, berikut adalah solusi menggunakan paket Pandas yang populer:

import pandas as pd

s = pd.Series(my_list)

>>> s * 5
0     5
1    10
2    15
3    20
4    25
dtype: int64

Atau, jika Anda hanya ingin daftarnya:

>>> (s * 5).tolist()
[5, 10, 15, 20, 25]

Pendekatan yang sangat cepat adalah melakukan perkalian dengan cara vektor daripada mengulang daftar. Numpy telah menyediakan cara yang sangat sederhana dan praktis untuk hal ini yang dapat Anda gunakan.

>>> import numpy as np
>>> 
>>> my_list = np.array([1, 2, 3, 4, 5])
>>> 
>>> my_list * 5
array([ 5, 10, 15, 20, 25])

Perhatikan bahwa ini tidak berfungsi dengan daftar asli Python. Jika Anda mengalikan angka dengan daftar, item tersebut akan berulang sebagai ukuran angka itu.

In [15]: my_list *= 1000

In [16]: len(my_list)
Out[16]: 5000

Jika Anda menginginkan pendekatan berbasis Python murni menggunakan pemahaman daftar pada dasarnya adalah cara yang paling Pythonic untuk pergi.

In [6]: my_list = [1, 2, 3, 4, 5]

In [7]: [5 * i for i in my_list]
Out[7]: [5, 10, 15, 20, 25]

Selain pemahaman daftar, sebagai pendekatan fungsional murni, Anda juga dapat menggunakan map()fungsi bawaan sebagai berikut:

In [10]: list(map((5).__mul__, my_list))
Out[10]: [5, 10, 15, 20, 25]

Kode ini melewati semua item dalam my_listuntuk 5's __mul__metode dan kembali iterator-seperti objek (dalam python-3.x). Anda kemudian dapat mengonversi iterator ke daftar menggunakan list()fungsi mapbawaan (dengan Python-2.x Anda tidak memerlukannya karena mengembalikan daftar secara default).

tolak ukur:

In [18]: %timeit [5 * i for i in my_list]
463 ns ± 10.6 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

In [19]: %timeit list(map((5).__mul__, my_list))
784 ns ± 10.7 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

In [20]: %timeit [5 * i for i in my_list * 100000]
20.8 ms ± 115 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)

In [21]: %timeit list(map((5).__mul__, my_list * 100000))
30.6 ms ± 169 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)


In [24]: arr = np.array(my_list * 100000)

In [25]: %timeit arr * 5
899 µs ± 4.98 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

Anda dapat melakukannya di tempat seperti ini:

 l = [1, 2, 3, 4, 5]
 l[:] = [x * 5 for x in l]

Ini tidak memerlukan impor tambahan dan sangat pythonic.

Karena saya pikir Anda baru dengan Python, mari lakukan jauh, iterasi melalui daftar Anda menggunakan for loop dan kalikan dan tambahkan setiap elemen ke daftar baru.

menggunakan for loop

lst = [5, 20 ,15]
product = []
for i in lst:
    product.append(i*5)
print product

menggunakan pemahaman daftar, ini juga sama dengan menggunakan for-loop tetapi lebih 'pythonic'

lst = [5, 20 ,15]

prod = [i * 5 for i in lst]
print prod

Dengan peta (tidak sebagus, tapi pendekatan lain untuk masalah ini):

list(map(lambda x: x*5,[5, 10, 15, 20, 25]))

juga, jika Anda kebetulan menggunakan array numpy atau numpy, Anda dapat menggunakan ini:

import numpy as np
list(np.array(x) * 5)

from functools import partial as p
from operator import mul
map(p(mul,5),my_list)

adalah salah satu cara Anda dapat melakukannya ... guru Anda mungkin tahu cara yang jauh lebih sederhana yang mungkin dibahas di kelas

Mengalikan setiap elemen my_listdengan k:

k = 5
my_list = [1,2,3,4]
result = list(map(lambda x: x * k, my_list))

yang menghasilkan: [5, 10, 15, 20]

Cara terbaik adalah menggunakan pemahaman daftar:

def map_to_list(my_list, n):
# multiply every value in my_list by n
# Use list comprehension!
    my_new_list = [i * n for i in my_list]
    return my_new_list
# To test:
print(map_to_list([1,2,3], -1))

Mengembalikan: [-1, -2, -3]