อาร์เรย์ NumPy: บทนำ [พร้อมตัวอย่าง]

ต้องการเริ่มต้นกับ NumPy หรือไม่ คู่มือนี้จะสอนคุณเกี่ยวกับพื้นฐานของอาร์เรย์ NumPy ใน Python

ในขั้นแรก คุณจะได้เรียนรู้ว่าอาร์เรย์ NumPy ทำงานแตกต่างจากรายการ Python อย่างไร จากนั้น คุณจะได้เรียนรู้หลายวิธีในการสร้างอาร์เรย์ NumPy และดำเนินการขั้นพื้นฐานกับอาร์เรย์เหล่านั้น

เอาล่ะ!

พื้นฐานของอาร์เรย์ NumPy

NumPy เป็นหนึ่งในไลบรารี Python ที่ได้รับความนิยมสูงสุดสำหรับการคำนวณทางวิทยาศาสตร์และการวิเคราะห์ข้อมูล โครงสร้างข้อมูลพื้นฐานใน NumPy คืออาร์เรย์ N มิติ (ND อาร์เรย์) พวกมันมีความสามารถในการ แพร่ภาพ และทำให้เราสามารถ vectorize การดำเนินการเพื่อความรวดเร็ว และใช้ฟังก์ชันทางคณิตศาสตร์ในตัวเพื่อปรับปรุงประสิทธิภาพ

ในการเริ่มทำงานกับ NumPy ขั้นแรกคุณควรติดตั้งไลบรารีและนำเข้าสู่สภาพแวดล้อมการทำงานของคุณ มีให้ในรูปแบบแพ็คเกจ PyPI ที่สามารถติดตั้งได้ผ่าน pip

ในการติดตั้ง NumPy ให้เปิดเทอร์มินัลแล้วรันคำสั่งต่อไปนี้:

 pip3 install numpy

หลังจากติดตั้ง NumPy แล้ว คุณสามารถอิมพอร์ตเข้าสู่สภาพแวดล้อมการทำงานโดยใช้นามแฝงได้ นามแฝงปกติคือ np

 import numpy as np

หมายเหตุ : การนำเข้า NumPy ภายใต้นามแฝง np ไม่ใช่ข้อกำหนด แต่เป็นแบบแผนที่แนะนำ

Python Lists เทียบกับ NumPy Arrays

พิจารณารายการตัวเลข Python ต่อไปนี้:

 py_list = [1,2,3,4]

คุณสามารถรับอาร์เรย์ NumPy จากรายการที่มีอยู่ได้โดยการเรียกใช้ np.array() โดยมีรายการเป็นอาร์กิวเมนต์

 np_arr1 = np.array(py_list) print(np_arr1) [1 2 3 4]

หากต้องการตรวจสอบประเภทของ np_arr1 ให้เรียกใช้ฟังก์ชัน type() ในตัว คุณจะเห็นว่าเป็น ndarray ซึ่งเป็นโครงสร้างข้อมูลพื้นฐานใน NumPy

 type(np_arr1) # numpy.ndarray

แม้ว่ารายการ Python และอาร์เรย์ NumPy อาจดูคล้ายกัน แต่มีความแตกต่างบางประการ:

• รายการ Python สามารถเก็บวัตถุประเภทข้อมูลที่ แตกต่างกัน ในขณะที่อาร์เรย์ NumPy มีองค์ประกอบของข้อมูลประเภท เดียวกัน ชนิดข้อมูลเริ่มต้นคือทศนิยมที่มีความแม่นยำ 64 บิต (float64)
• องค์ประกอบของรายการ Python ไม่จำเป็นต้องเก็บไว้ในตำแหน่งที่อยู่ติดกันในหน่วยความจำ อย่างไรก็ตาม องค์ประกอบของอาร์เรย์ NumPy จะถูกจัดเก็บไว้ในบล็อกที่ อยู่ติดกัน ในหน่วยความจำ เป็นผลให้ค้นหาและเข้าถึงองค์ประกอบได้เร็วขึ้น

มาดูความแตกต่างอีกสองสามข้อ

แพร่ภาพ

คุณลักษณะอันทรงพลังของอาร์เรย์ NumPy กำลังแพร่ภาพ สมมติว่าเราต้องการเพิ่ม 2 ให้กับองค์ประกอบทั้งหมดของ np_arr1 และ py_list

ลองเพิ่ม 2 ใน py_list แล้วดูว่าเกิดอะไรขึ้น:

 >>> py_list + 2

เราพบว่าเราได้รับ TypeError ที่ระบุว่าเราสามารถเชื่อมสองรายการเข้าด้วยกันเท่านั้น และไม่รองรับการเพิ่ม py_list + 2 แบบนี้

 --------------------------------------------------------------------------- TypeError Traceback (most recent call last) <ipython-input-5-c0f9974899df> in <module> ----> 1 py_list + 2 TypeError: can only concatenate list (not "int") to list

มาลองดำเนินการเดียวกันกับอาร์เรย์ np_arr1

 >>> np_arr1 + 2

ในผลลัพธ์ เราจะเห็นว่ามีการเพิ่ม 2 ในแต่ละองค์ประกอบของอาร์เรย์

 array([3, 4, 5, 6])

นี่เป็นเพราะ NumPy เผยแพร่สเกลาร์ 2 โดยปริยายไปยังอาร์เรย์ของรูปร่างที่เข้ากันได้เพื่อให้ผลลัพธ์นี้

การทำให้เป็นเวกเตอร์

อาร์เรย์ NumPy รองรับเวกเตอร์เพื่อการดำเนินการตามองค์ประกอบที่เร็วขึ้น สมมติว่าเราต้องการหาผลรวมเชิงองค์ประกอบของอาร์เรย์ทั้งสอง

การใช้การดำเนินการ + อย่างง่ายในรายการจะส่งคืนการต่อข้อมูลของสองรายการ (ซึ่งไม่ใช่สิ่งที่เราต้องการ!)

 >>> py_list + py_list # [1, 2, 3, 4, 1, 2, 3, 4]

แต่การดำเนินการเดียวกันบนอาร์เรย์ NumPy, np_arr1 จะส่งกลับผลรวมขององค์ประกอบที่ชาญฉลาดของ np_arr1 ด้วยตัวมันเอง

 >>> np_arr1 + np_arr1 # array([2, 4, 6, 8])

ในทำนองเดียวกัน รายการที่ซ้อนกันอาจมีโครงสร้างคล้ายกับอาร์เรย์ NumPy มิติ N อย่างไรก็ตาม ความแตกต่างที่กล่าวถึงยังคงมีอยู่

 nested_list = [[1,2],[3,4],[5,6]] np_arr2 = np.array(nested_list) print(np_arr2)

 [[1 2] [3 4] [5 6]]

วิธีสร้างอาร์เรย์ NumPy

คุณสามารถสร้างอาร์เรย์ NumPy จากรายการ Python ที่มีอยู่ได้ตลอดเวลาโดยใช้ np.array(list-obj) อย่างไรก็ตาม นี่ไม่ใช่วิธีที่มีประสิทธิภาพที่สุด

คุณสามารถใช้ฟังก์ชันในตัวหลายฟังก์ชันที่ให้คุณสร้างอาร์เรย์ของรูปร่างเฉพาะแทนได้ รูปร่างของอาร์เรย์คือทูเพิลที่แสดงขนาดของอาร์เรย์ตามแต่ละมิติ ตัวอย่างเช่น รูปร่างของอาร์เรย์ 2×2 ที่มีสองแถวและสองคอลัมน์คือ (2,2) ในส่วนนี้ เราจะเรียนรู้วิธีใช้ฟังก์ชันในตัวเหล่านี้บางส่วน

การสร้างอาร์เรย์ของศูนย์และหนึ่ง

มักจะเป็นประโยชน์ในการสร้างอาร์เรย์ของมิติข้อมูลเฉพาะที่มีศูนย์ทั้งหมดหรือทั้งหมด แล้วนำไปใช้แก้ไขในขั้นตอนต่อๆไปในโปรแกรม

เราสามารถใช้ zeros() เพื่อสร้างอาร์เรย์ของเลขศูนย์ ผ่านรูปร่างของอาร์เรย์ที่ต้องการเป็นทูเพิล: np.zeros(shape)

 array0 = np.zeros((3,3)) print(array0)

นี่คือผลลัพธ์ อาร์เรย์ 2 มิติของศูนย์:

 [[0. 0. 0.] [0. 0. 0.] [0. 0. 0.]]

คุณสามารถเข้าถึงแอตทริบิวต์ของอาร์เรย์ NumPy, เรียกแอตทริบิวต์ เช่น dtype และ shape โดยใช้เครื่องหมายจุด ดังที่แสดงด้านล่าง:

 print(array0.dtype) # float64 print(array0.shape) # (3, 3)

หากต้องการรับอาร์เรย์ คุณสามารถใช้ np.ones()

 array1 = np.ones((3,3)) print(array1)

 [[1. 1. 1.] [1. 1. 1.] [1. 1. 1.]]

การสร้าง Identity Matrix

เมทริกซ์เอกลักษณ์ถูกนำมาใช้กันอย่างแพร่หลายในหลาย ๆ แอปพลิเคชันในพีชคณิตเชิงเส้น และคุณสามารถใช้ np.eye() เพื่อสร้างเมทริกซ์เอกลักษณ์ np.eye() รับอาร์กิวเมนต์เพียงหนึ่งอาร์กิวเมนต์: ลำดับของเมทริกซ์ ( n )

 arrayi = np.eye(3) print(arrayi)

 [[1. 0. 0.] [0. 1. 0.] [0. 0. 1.]]

การสร้างอาร์เรย์ของตัวเลขสุ่ม

คุณยังสามารถสร้างอาร์เรย์ของรูปร่างเฉพาะที่เติมด้วยตัวเลขสุ่มที่มาจากการแจกแจงเฉพาะ การแจกแจงความน่าจะเป็นที่ใช้กันทั่วไปคือการแจกแจงแบบสม่ำเสมอและการแจกแจงแบบปกติมาตรฐาน

randn() ซึ่งเป็นส่วนหนึ่งของโมดูล random ของ NumPy สามารถใช้สร้างอาร์เรย์ของตัวเลขที่สุ่มตัวอย่างจากการ แจกแจงแบบปกติมาตรฐาน การแจกแจงแบบปกติมาตรฐานคือการแจกแจงแบบเกาส์เซียนที่มีค่าเฉลี่ยเป็นศูนย์และความแปรปรวนของหน่วย

 std_arr = np.random.randn(3,4) print(std_arr)

 [[-0.13604072 1.21884359 2.06850932 0.78212093] [ 0.44314719 -0.78084801 -0.70517138 1.17984949] [ 1.13214829 1.02339351 0.15317809 1.83191128]]

np.random.rand() ส่งคืนอาร์เรย์ของตัวอย่างตัวเลขจากการ แจกแจงแบบสม่ำเสมอ ในช่วง [0,1)

 uniform_arr = np.random.rand(2,3) print(uniform_arr)

 [[0.90470384 0.18877441 0.10021817] [0.741 0.10657658 0.71334643]]

คุณยังสามารถสร้างอาร์เรย์ของจำนวนเต็มแบบสุ่มโดยใช้ฟังก์ชัน randint() ซึ่งเป็นส่วนหนึ่งของโมดูลสุ่มของ NumPy np.random.randint(low, high, size) ส่งคืนอาร์เรย์ของจำนวนเต็ม รูปร่างของอาร์เรย์จะอนุมานจากอาร์กิวเมนต์ size และจำนวนเต็มจะรับค่าในช่วงเวลา [low,high)

นี่คือตัวอย่าง:

 int_arr = np.random.randint(1,100,(2,3)) print(int_arr)

 [[53 89 33] [24 85 33]]

ฟังก์ชันในตัวที่มีประโยชน์อื่นๆ

ต่อไป มาดูฟังก์ชันที่มีประโยชน์อื่นๆ สองสามอย่างเพื่อสร้างอาร์เรย์ NumPy

ฟังก์ชัน arange() ส่งคืนอาร์เรย์ของตัวเลขระหว่างค่า start และค่า stop เป็นขั้นของค่า step : start , start + step , start + 2*step up to แต่ไม่รวม stop ค่า start และค่า step เป็น ตัวเลือก ขนาดขั้นตอนเริ่มต้นคือ 1 และค่าเริ่มต้นเริ่มต้นคือ 0

ในตัวอย่างนี้ array_a เป็นอาร์เรย์ของตัวเลขที่เริ่มต้นที่ 1 ไปจนถึง 10 แต่ไม่รวม 10 ในขั้นตอนที่ 0.5

 array_a = np.arange(1,10,0.5) print(array_a)

 [1. 1.5 2. 2.5 3. 3.5 4. 4.5 5. 5.5 6. 6.5 7. 7.5 8. 8.5 9. 9.5]

คุณยังสามารถสร้างอาร์เรย์ของตัวเลขที่มีระยะห่างเท่าๆ กันโดยใช้ np.linspace() ใช้ np.linspace(start, stop, num) เพื่อรับอาร์เรย์ของ num ที่เว้นระยะเท่าๆ กันระหว่างค่า start และ stop

ในที่นี้ arr_lin คืออาร์เรย์ของตัวเลขที่เว้นระยะเท่าๆ กัน 5 ตัวในช่วง [1,10]

 array_lin = np.linspace(1,10,5) print(array_lin)

 [ 1. 3.25 5.5 7.75 10. ]

ในทำนองเดียวกัน arr_lin2 เป็นอาร์เรย์ของตัวเลขที่เว้นระยะเท่าๆ กัน 10 ตัวในช่วง [1,20]

 array_lin2 = np.linspace(1,20,10) print(array_lin2)

 [ 1. 3.11111111 5.22222222 7.33333333 9.44444444 11.55555556 13.66666667 15.77777778 17.88888889 20. ]

ไม่เหมือนกับฟังก์ชัน arange() ฟังก์ชัน linspace() รวม จุดสิ้นสุดตามค่าเริ่มต้น

การทำงานพื้นฐานบนอาร์เรย์ NumPy

ต่อไป มาดูการดำเนินการพื้นฐานบางอย่างบนอาร์เรย์ NumPy

การหาองค์ประกอบขั้นต่ำและสูงสุด

เมื่อใดก็ตามที่เราใช้ฟังก์ชันจากโมดูลสุ่มของ NumPy เพื่อสร้างอาร์เรย์ เราจะได้ผลลัพธ์ที่แตกต่างกันทุกครั้งที่รันโค้ด เพื่อให้ได้ผลลัพธ์ที่ทำซ้ำได้ เราควรตั้งค่า seed: np.random.seed(seed_value)

ในตัวอย่างต่อไปนี้ ฉันได้ตั้งค่า seed สำหรับความสามารถในการทำซ้ำ int_arr1 เป็นอาร์เรย์ของจำนวนเต็มสุ่มเจ็ดค่าในช่วงเวลา [1,100)

 np.random.seed(27) int_arr1 = np.random.randint(1,100,7) print(int_arr1) # [20 57 73 32 57 38 25]

• หากต้องการค้นหาองค์ประกอบสูงสุดในอาร์เรย์ คุณสามารถเรียกใช้เมธอด max() บนวัตถุอาร์เรย์ int_arr1 และ
• หากต้องการค้นหาองค์ประกอบขั้นต่ำในอาร์เรย์ คุณสามารถเรียกใช้เมธอด min() บนวัตถุอาร์เรย์ int_arr1

 int_arr1.max() # 73 int_arr1.min() # 20

การหาดัชนีขององค์ประกอบสูงสุดและต่ำสุด

บางครั้ง คุณอาจต้องหาดัชนีขององค์ประกอบสูงสุดและต่ำสุด ในการทำเช่นนี้ คุณสามารถเรียกใช้เมธอด argmax( argmax() และ argmin() บนวัตถุอาร์เรย์

ที่นี่ องค์ประกอบสูงสุด 73 เกิดขึ้นที่ดัชนี 2

 int_arr1.argmax() # 2

และองค์ประกอบขั้นต่ำ 20 เกิดขึ้นที่ดัชนี 0

 int_arr1.argmin() # 0

คุณยังสามารถใช้ np.argmax(array) และ np.argmin(array) เพื่อค้นหาดัชนีขององค์ประกอบสูงสุดและต่ำสุดตามลำดับ เรียนรู้เพิ่มเติมเกี่ยวกับฟังก์ชัน NumPy argmax()

วิธีเชื่อมต่อ NumPy Arrays

การดำเนินการทั่วไปอื่นที่คุณอาจต้องการดำเนินการกับอาร์เรย์ NumPy คือการต่อข้อมูล

การต่อข้อมูลในแนวตั้งโดยใช้ vstack

คุณสามารถเชื่อมอาร์เรย์ในแนวตั้งโดยใช้ vstack()

นี่คือตัวอย่าง arr1 เป็นอาร์เรย์ของแถวที่มีสองแถวและสามคอลัมน์ และ arr2 เป็นอาร์เรย์ของศูนย์ที่มีสองแถวและสามคอลัมน์

 arr1 = np.ones((2,3)) arr2 = np.zeros((2,3))

เราสามารถเชื่อมอาร์เรย์ทั้งสองนี้ในแนวตั้งโดยใช้ vstack() ดังที่แสดง:

 np.vstack((arr1,arr2))

 array([[1., 1., 1.], [1., 1., 1.], [0., 0., 0.], [0., 0., 0.]])

เมื่อการซ้อนเกิดขึ้นในแนวตั้ง อาร์เรย์ทั้งสองควรมีจำนวน คอลัมน์ เท่า กัน

เปลี่ยน arr2 ให้เป็นรูป (2,2) กันเถอะ ตอนนี้มีสองแถวและสองคอลัมน์

 arr1 = np.ones((2,3)) arr2 = np.zeros((2,2)) np.vstack((arr1,arr2))

ดังนั้น การต่อข้อมูลในแนวตั้งจึงเป็นไปไม่ได้ และเราได้รับ ValueError

 --------------------------------------------------------------------------- ValueError Traceback (most recent call last) <ipython-input-21-d5d3bf37fc21> in <module> ----> 1 np.vstack((arr1,arr2)) ValueError: all the input array dimensions for the concatenation axis must match exactly, but along dimension 1, the array at index 0 has size 3 and the array at index 1 has size 2

การต่อข้อมูลในแนวนอนโดยใช้ hstack

คุณสามารถเชื่อมอาร์เรย์ NumPy ในแนวนอนโดยใช้ hstack() ดังที่แสดงด้านล่าง

 arr1 = np.ones((3,3)) arr2 = np.zeros((3,2))

 np.hstack((arr1,arr2))

เนื่องจากการซ้อนเกิดขึ้นในแนวนอน อาร์เรย์อินพุตควรมีจำนวน แถว เท่า กัน ที่นี่ ทั้ง arr1 และ arr2 มีสามแถว

 array([[1., 1., 1., 0., 0.], [1., 1., 1., 0., 0.], [1., 1., 1., 0., 0.]])

ใช้เชื่อมต่อ

คุณยังสามารถใช้การเชื่อมอาร์เรย์ NumPy ตามแกนที่ระบุโดยใช้ฟังก์ชัน concatenate() ตั้งค่าอาร์กิวเมนต์ axis ที่เป็นทางเลือกให้กับแกนที่คุณต้องการต่อเข้าด้วยกัน ค่าเริ่มต้น ของแกนคือศูนย์

นี่คือตัวอย่างบางส่วน:

 arr1 = np.ones((2,3)) arr2 = np.zeros((2,3))

เมื่อเราไม่ได้ระบุแกนที่จะเชื่อมกัน อาร์เรย์จะเชื่อมตามแกน 0 ในอาร์เรย์ผลลัพธ์ อาร์เรย์ที่สอง arr2 จะถูกเพิ่ม (เป็นแถว) ใต้อาร์เรย์แรก

 np.concatenate((arr1,arr2))

 array([[1., 1., 1.], [1., 1., 1.], [0., 0., 0.], [0., 0., 0.]])

เมื่อเราระบุ axis = 1 เราจะได้ผลลัพธ์ดังนี้ arr2 ถูกเชื่อม (เป็นคอลัมน์) ข้างอาร์เรย์แรก arr1

 np.concatenate((arr1,arr2),axis=1)

 array([[1., 1., 1., 0., 0., 0.], [1., 1., 1., 0., 0., 0.]])

เช่นเดียวกับ hstack() และ vstack() ขนาดของอาร์เรย์ ตามแกนการต่อข้อมูลควรตรงกัน

บทสรุป

ในบทช่วยสอนนี้ คุณได้เรียนรู้ความแตกต่างระหว่างอาร์เรย์ NumPy และรายการ Python โดยมุ่งเน้นที่ข้อดีของอาร์เรย์ N มิติในแง่ของความเร็วและประสิทธิภาพ

คุณยังได้เรียนรู้ฟังก์ชันที่มีประโยชน์หลายอย่างเพื่อสร้างอาร์เรย์ของมิติเฉพาะและดำเนินการทั่วไป เช่น การค้นหาองค์ประกอบต่ำสุดและสูงสุด การเชื่อมอาร์เรย์ และอื่นๆ

จากนั้น เรียนรู้วิธีปรับรูปร่างอาร์เรย์ NumPy ใหม่