Nama variabel yang dimulai dengan huruf besar bukanlah Pythonic. Dan itu daftar, bukan angka. Jadi saya sarankan gunakan l1dan l2sebagai nama variabel.
Casimir Crystal
4
Penggunaan 'l' sebagai variabel juga tidak disarankan karena huruf 'l' dan angka 1 mudah membingungkan. Saya menggunakan variabel dalam pertanyaan awal OP, dan saya yakin suntingan Anda atas pertanyaan itu lebih banyak ruginya daripada kebaikan.
Alexander
1
Jika Anda merasa hasil edit saya buruk, Anda dapat mengedit pertanyaan untuk memperbaikinya. Juga, kita dapat memilih variabel lain daripada l1seperti l_1, list_1, dll Ini semua lebih baik dari Num_1.
Casimir Crystal
26
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.
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 * 5899 µs ± 4.98 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
Saya tertarik mengapa metode numpy 'sangat cepat'? Bisakah Anda menjelaskan atau mengarahkan saya ke beberapa sumber? Saya tidak yakin apa itu vektorisasi.
@Kasramvd Tautan itu salah. Tautan ini membahas arti vektorisasi yang berbeda sebagai instruksi-tunggal-banyak-data (menerapkan operasi ke banyak data sekaligus, seperti yang dilakukan GPU). Dalam konteks NumPy, vektorisasi mengacu pada penggunaan loop C cepat yang telah dikompilasi sebelumnya untuk beroperasi pada urutan data, bukan Python murni.
Selain itu: konsep ini disebut pemahaman daftar jika Anda ingin mencari informasi lebih lanjut tentangnya.
Michael
1
Saya lebih suka l = [x * 5 for x in l]berakhir l[:] = [x * 5 for x in l]. Yang terakhir membuat daftar baru, lalu menggunakannya untuk menimpa konten ldaripada hanya menetapkan ulang referensi yang lebih murah. Jika Anda benar-benar khawatir tentang luar angkasa, cukup lakukan iterasi dengan loop dan mutasi di tempat.
cs95
6
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 * 5for i in lst]
print prod
Bagaimana cara "jauh" lebih baik? Lebih panjang — jadi lebih sulit dibaca — dan tidak lebih mudah untuk menulis.
lirtosiast
1
oke mungkin Anda mendapat kesan yang salah pada judul saya dan saya tidak pernah mengatakan itu lebih baik, hanya mencoba menunjukkan kepadanya bagaimana melakukannya tanpa menggunakan pemahaman. karena pada pengalaman saya ketika saya masih baru di python saya tidak dapat memahami konsep pemahaman dengan mudah.
tawon8898
Oh baiklah. Saya tidak bisa langsung berhubungan karena saya mulai dengan bahasa fungsional.
lirtosiast
Aku mengerti, baiklah disana. Saya mengedit jawabannya untuk juga memasukkan cara efisien melakukannya.
tawon8898
4
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:
Anda bisa melakukannya tanpa pernyataan import menggunakan ekspresi lambda. Selain itu, cuplikan Anda mengembalikan objek peta, yang tidak berguna kecuali dilemparkan ke daftar. daftar (peta (lambda x: 5 * x, daftar_saya)).
castle-bravo
@ castle-bravo kegunaannya tergantung pada apa yang perlu Anda lakukan dengannya ... ada banyak cara untuk mencapai solusi ini (seperti yang saya sebutkan ...)
Joran Beasley
4
Harap jangan mengajari orang untuk menggunakan mapdengan lambda; saat Anda membutuhkan lambda, Anda akan lebih baik dengan pemahaman daftar atau ekspresi generator. Jika Anda pintar, Anda dapat membuat mappekerjaan tanpa lambdabanyak, misalnya dalam kasus ini map((5).__mul__, my_list), meskipun dalam kasus khusus ini, berkat beberapa pengoptimalan dalam penerjemah kode byte untuk intmatematika sederhana , [x * 5 for x in my_list]lebih cepat, serta lebih Pythonic dan lebih sederhana .
ShadowRanger
1
Mengalikan setiap elemen my_listdengan k:
k = 5
my_list = [1,2,3,4]
result = list(map(lambda x: x * k, my_list))
defmap_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))
Ini hanya mengambil jawaban yang diterima dan mengubahnya menjadi sebuah fungsi. Anda mungkin bisa melakukannya dengan lebih dari setengah tanggapan di SO, tetapi itu tidak menambahkan apa-apa dan bukan apa yang diminta OP.
map
lebih baik darifor-loop
.map
(dan selalu lebih baik jikamap
membutuhkan alambda
).Jawaban:
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
for
perulangan: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]
sumber
l1
danl2
sebagai nama variabel.l1
sepertil_1
,list_1
, dll Ini semua lebih baik dariNum_1
.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_list
untuk5
's__mul__
metode dan kembali iterator-seperti objek (dalam python-3.x). Anda kemudian dapat mengonversi iterator ke daftar menggunakanlist()
fungsimap
bawaan (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)
sumber
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.
sumber
l = [x * 5 for x in l]
berakhirl[:] = [x * 5 for x in l]
. Yang terakhir membuat daftar baru, lalu menggunakannya untuk menimpa kontenl
daripada hanya menetapkan ulang referensi yang lebih murah. Jika Anda benar-benar khawatir tentang luar angkasa, cukup lakukan iterasi dengan loop dan mutasi di tempat.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
sumber
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)
sumber
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
sumber
map
denganlambda
; saat Anda membutuhkanlambda
, Anda akan lebih baik dengan pemahaman daftar atau ekspresi generator. Jika Anda pintar, Anda dapat membuatmap
pekerjaan tanpalambda
banyak, misalnya dalam kasus inimap((5).__mul__, my_list)
, meskipun dalam kasus khusus ini, berkat beberapa pengoptimalan dalam penerjemah kode byte untukint
matematika sederhana ,[x * 5 for x in my_list]
lebih cepat, serta lebih Pythonic dan lebih sederhana .Mengalikan setiap elemen
my_list
dengank
:k = 5 my_list = [1,2,3,4] result = list(map(lambda x: x * k, my_list))
yang menghasilkan:
[5, 10, 15, 20]
sumber
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]
sumber