Mengapakah data besar Python mesti menggunakan Numpy Array?

Numpy ialah modul teras pengkomputeran saintifik Python. Ia menyediakan objek tatasusunan yang sangat cekap, serta alat untuk bekerja dengan objek tatasusunan ini. Tatasusunan Numpy terdiri daripada banyak nilai, semuanya daripada jenis yang sama.

Pustaka teras Python menyediakan senarai Senarai. Senarai ialah salah satu jenis data Python yang paling biasa, dan ia boleh diubah saiz dan mengandungi unsur jenis yang berbeza, yang sangat mudah.

Jadi apakah perbezaan antara List dan Numpy Array? Mengapa kita perlu menggunakan Numpy Array semasa memproses data besar? Jawapannya ialah prestasi.

Struktur data Numpy berprestasi lebih baik dalam aspek berikut:

1. Saiz memori - Struktur data Numpy menduduki kurang memori.

2. Prestasi—Lapisan bawah Numpy dilaksanakan dalam bahasa C, yang lebih pantas daripada senarai.

3. Kaedah pengendalian - operasi algebra teroptimum terbina dalam dan kaedah lain.

Berikut akan menerangkan kelebihan tatasusunan Numpy berbanding Senarai dalam pemprosesan data besar.

1. Penggunaan memori yang lebih kecil

Dengan menggunakan tatasusunan Numpy dan bukannya Senarai, anda boleh mengurangkan penggunaan memori anda sebanyak 20 kali.

Untuk Senarai asli Python, kerana setiap kali objek baharu ditambahkan, 8 bait diperlukan untuk merujuk objek baharu dan objek baharu itu sendiri menduduki 28 bait (mengambil integer sebagai contoh). Jadi saiz senarai boleh dikira dengan formula berikut:

64 + 8 * len(lst) + len(lst) * 28 bait

Dan Menggunakan Numpy boleh mengurangkan banyak penggunaan ruang. Sebagai contoh, Array integer Numpy dengan panjang n memerlukan:

96 + len(a) * 8 bait

Dapat dilihat bahawa semakin besar tatasusunan, lebih besar tatasusunan Lebih banyak ruang memori disimpan. Dengan mengandaikan tatasusunan anda mempunyai 1 bilion elemen, maka perbezaan dalam penggunaan memori adalah pada tahap GB.

2. Kaedah pengiraan terbina dalam yang lebih pantas

Jalankan skrip berikut, yang juga menjana dua tatasusunan dimensi tertentu dan menambahkannya bersama-sama Anda boleh melihat prestasi Senarai asli dan Numpy Array jurang.

import time
import numpy as np
size_of_vec = 1000
def pure_python_version():
t1 = time.time()
X = range(size_of_vec)
Y = range(size_of_vec)
Z = [X[i] + Y[i] for i in range(len(X)) ]
return time.time() - t1
def numpy_version():
t1 = time.time()
X = np.arange(size_of_vec)
Y = np.arange(size_of_vec)
Z = X + Y
return time.time() - t1
t1 = pure_python_version()
t2 = numpy_version()
print(t1, t2)
print("Numpy is in this example " + str(t1/t2) + " faster!")

Hasilnya adalah seperti berikut:

0.00048732757568359375 0.0002491474151611328
Numpy is in this example 1.955980861244019 faster!

Seperti yang anda lihat, Numpy adalah 1.95 kali lebih pantas daripada tatasusunan asli.

Jika anda berhati-hati, anda juga boleh mendapati tatasusunan Numpy boleh terus melaksanakan operasi tambah. Tatasusunan asli tidak boleh melakukan ini. Ini adalah kelebihan kaedah operasi Numpy.

Kami akan melakukan beberapa lagi ujian berulang untuk membuktikan bahawa kelebihan prestasi ini tahan lama.

import numpy as np
from timeit import Timer
size_of_vec = 1000
X_list = range(size_of_vec)
Y_list = range(size_of_vec)
X = np.arange(size_of_vec)
Y = np.arange(size_of_vec)
def pure_python_version():
Z = [X_list[i] + Y_list[i] for i in range(len(X_list)) ]
def numpy_version():
Z = X + Y
timer_obj1 = Timer("pure_python_version()",
 "from __main__ import pure_python_version")
timer_obj2 = Timer("numpy_version()",
 "from __main__ import numpy_version")
print(timer_obj1.timeit(10))
print(timer_obj2.timeit(10)) # Runs Faster!
print(timer_obj1.repeat(repeat=3, number=10))
print(timer_obj2.repeat(repeat=3, number=10)) # repeat to prove it!

Hasilnya adalah seperti berikut:

0.0029753120616078377
0.00014940369874238968
[0.002683573868125677, 0.002754641231149435, 0.002803879790008068]
[6.536301225423813e-05, 2.9387418180704117e-05, 2.9171351343393326e-05]

Seperti yang anda lihat, masa keluaran kedua sentiasa lebih kecil, yang membuktikan bahawa kelebihan prestasi ini adalah berterusan.

Jadi, jika anda melakukan beberapa penyelidikan data besar, seperti data kewangan dan data stok, menggunakan Numpy boleh menjimatkan banyak ruang memori dan mempunyai prestasi yang lebih berkuasa.

Rujukan: ​​//m.sbmmt.com/link/5cce25ff8c3ce169488fe6c6f1ad3c97​​

Artikel kami berakhir di sini, jika anda suka Sila teruskan mengikuti kami untuk tutorial praktikal Python hari ini.

Atas ialah kandungan terperinci Mengapakah data besar Python mesti menggunakan Numpy Array?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!