การสร้างกราฟด้วย Matplotlib ใน Python (2024)

atplotlib เป็นไลบรารีที่มีประโยชน์มากในภาษาการเขียนโปรแกรม Python สำหรับการสร้างภาพข้อมูลและการสร้างกราฟ องค์ประกอบที่สำคัญอย่างหนึ่งคือ Pyplot ซึ่งประกอบด้วยฟังก์ชันคำสั่งต่าง ๆ ที่อนุญาตให้ผู้ใช้สร้างกราฟในรูปแบบที่คล้ายคลึงกับ MATLAB ในบทความนี้ เราจะทบทวนแนวคิดพื้นฐานของ Pyplot

Pyplot คือชุดของฟังก์ชันใน Matplotlib ที่ทำให้การสร้างกราฟง่ายขึ้น ฟังก์ชันเหล่านี้ทำงานในโหมดคำสั่ง ช่วยให้ควบคุมการแสดงข้อมูลเป็นภาพได้ดีขึ้น

  • การสร้างภาพ (ตัวเลข)

หน้าที่หลักของ Pyplot คือการสร้างรูปภาพ (ตัวเลข) รูปภาพนี้ทำหน้าที่เป็นคอนเทนเนอร์สำหรับองค์ประกอบการแสดงภาพทั้งหมดที่คุณจะสร้างขึ้น กระบวนการสร้างภาพดำเนินการด้วยคำสั่งง่ายๆ

  • การวางแผนพื้นที่

เมื่อคุณมีรูปภาพแล้ว คุณสามารถกำหนดพื้นที่การลงจุดภายในรูปภาพได้ นี่คือที่ที่คุณจะสร้างกราฟิก วาดเส้น และเพิ่มองค์ประกอบภาพอื่นๆ

  • พล็อตเส้นและข้อมูล

Pyplot อนุญาตให้ผู้ใช้ลงจุดบรรทัดและข้อมูลในพื้นที่การลงจุดที่กำหนดไว้ล่วงหน้า คุณสามารถสร้างกราฟตามข้อมูลที่คุณมีได้อย่างง่ายดาย

  • การเพิ่มป้ายกำกับและข้อความ

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

  • ขั้นตอนตามลำดับ

สิ่งที่น่าสนใจคือ Pyplot ให้คุณทำทั้งหมดนี้ในขั้นตอนต่อเนื่องกัน กล่าวอีกนัยหนึ่ง คุณสามารถเปลี่ยนแปลงรูปภาพเดียวกันได้หลายครั้งโดยไม่สูญเสียผลลัพธ์ก่อนหน้า

ในตัวอย่างง่ายๆ นี้ เราจะเรียนรู้วิธีพล็อตรายการตัวเลขเดี่ยว เช่น [1.0, 2.0, 4.0, 8.0, 16.0, 32.0, 64.0] โดยใช้ Python และ Matplotlib

  • ในการดำเนินการนี้ เราใช้ไลบรารี Matplotlib โดยการนำเข้าmatplotlib.pyplotเช่นpltดังต่อไปนี้
1 #Code1: เขียนรายการตัวเลขเดี่ยวๆ
2 นำเข้า matplotlib.pyplot ad plt
3
4 พล็อต ([1.0,2.0,4.0,8.0,16.0,32.0,64.0])
5 plt.show()
  • ในบรรทัดที่ 4 เราใช้ฟังก์ชันพล็อต()เพื่อสร้างกราฟเส้นเชื่อมตัวเลขในรายการ กราฟนี้จะเป็นรูปแบบที่เราเห็นในรูปที่ 1
การสร้างกราฟด้วย Matplotlib ใน Python (2)
  • สิ่งสำคัญคือต้องทราบว่าหากเราระบุรายการตัวเลขเพียงรายการเดียวให้กับฟังก์ชันพล็อต(), Matplotlib จะพิจารณาว่าเป็นลำดับของค่าพิกัด (ค่า y) และค่า Abscissa (ค่า x) จะถูกสร้างขึ้นโดยอัตโนมัติ ค่า Abscissa เหล่านี้เป็นจำนวนเต็มธรรมชาติติดต่อกันโดยเริ่มต้นที่ 0 โดยมีความยาวเท่ากับรายการค่า y
  • ในกรณีของเรา สิ่งนี้จะสร้างพล็อตที่ถูกต้อง เนื่องจากจริงๆ แล้วเรากำลังพล็อตความสัมพันธ์ y = 2^x
  • อย่างไรก็ตาม ในสถานการณ์ทั่วไป เราสามารถให้รายการฟังก์ชันที่มีความยาวเท่ากันได้สองรายการพล็อต(). รายการแรกจะถือเป็นรายการค่า Abscissa ในขณะที่รายการที่สองถือเป็นรายการค่าลำดับ ด้วยเหตุนี้ เราจึงสามารถควบคุมการแสดงกราฟได้ดีขึ้น
  • นอกจากนี้เรายังสามารถเพิ่มอาร์กิวเมนต์ที่สามที่เป็นทางเลือกให้กับฟังก์ชันได้พล็อต()ซึ่งเป็นสตริงรูปแบบ สิ่งนี้ช่วยให้เราสามารถกำหนดสีและประเภทของเส้นบนโครงเรื่องได้ ตัวอย่างเช่น สตริงรูปแบบเริ่มต้น 'b-' จะสร้างเส้นทึบสีน้ำเงิน ดังแสดงในรูปที่ 1
  • ตัวอย่างเพิ่มเติมมีให้ใน Code2 (รูปที่ 2) ซึ่งแสดงให้เห็นการใช้สตริงรูปแบบเพิ่มเติมเพื่อปรับเปลี่ยนการแสดงผลกราฟิก
1 # Code2: แก้ไขการแสดงกราฟ
2 นำเข้า matplotlib pyplot เป็น plt
3 #
4 พล็อต ([3.0,4.0,5.0,6.0,7.0,8.0],[8.0,16.0,32.0,64.0,128.0,256.0], 'ro')
5 plt.show( )
  • ในบรรทัดที่ 4 เราใช้ฟังก์ชันพล็อต()เพื่อผ่านสองรายการ x และ y สตริง'โร', ขอพล็อต()เพื่อแสดงโครงเรื่องเป็นวงกลมสีแดง () (โอ). ส่วนใน Matplotlib จะใช้เพื่อแสดงสีแดงและโอใช้เป็นเครื่องหมายระบุจุดศูนย์กลางด้วยสีแดงดังรูปที่ 2 จริงๆ แล้วค่าเริ่มต้นของรหัสนี้คือ'ข-'ซึ่งสร้างเส้นสีน้ำเงินซึ่งมีความต่อเนื่อง- -ดังแสดงในรูปที่ 1
การสร้างกราฟด้วย Matplotlib ใน Python (3)
  • สิ่งสำคัญคือต้องจำไว้ว่า Matplotlib ไม่เพียงแต่ทำงานกับรายการเท่านั้น เพื่อการประมวลผลตัวเลขที่สะดวกยิ่งขึ้น เรามักจะใช้อาร์เรย์ที่เป็นตัวเลขแทนการสร้างรายการด้วยตนเอง ที่จริงแล้ว ลำดับทั้งหมดจะถูกแปลงเป็นอาร์เรย์จำนวนมากภายใน
  • ใน Code3 เราจะเห็นตัวอย่างของการใช้รูปแบบที่แตกต่างกันเพื่อพล็อตสามบรรทัดที่แตกต่างกันในคำสั่งเดียวโดยใช้อาร์เรย์ (รูปที่ 3)
1 #Code3: ลงจุดกราฟซ้อน
2 นำเข้า matplotlib pyplot เป็น plt
3 นำเข้าตัวเลขเป็น np
4 #
5 x=เอ็นพี จัดเรียง (0.0 ,2.0 ,0.05)
6 พ.ย. พล็อต (x,x,x,np. sqrt (x) , 'ro ' ,x,x∗∗2, 'g^ ' )
7 plt .show( )
การสร้างกราฟด้วย Matplotlib ใน Python (4)
  • เราใช้ฟังก์ชั่นพล็อต()ใน Matplotlib เพื่อสร้างพล็อตสามประเภทในรูปที่ 3 ขั้นแรกเราสร้างอาร์เรย์ x ที่มีค่าตั้งแต่ 0 ถึง 1.95 จากนั้นเราก็ใช้พล็อต()เพื่อวาดเส้นตรง y = x ซึ่งเป็นสีน้ำเงินตามค่าเริ่มต้น ต่อไปเราใช้พล็อต()อีกครั้งเพื่อวาด y = √x ด้วยวงกลมสีแดง สุดท้ายนี้เราใช้พล็อต()อีกครั้งเพื่อวาด y = x^2 ด้วยสามเหลี่ยมสีเขียว แปลงทั้งหมดเหล่านี้แสดงในภาพเดียว

เราสามารถวาดกราฟสำหรับฟังก์ชันทุกประเภทที่มีอยู่ในแพ็คเกจได้มากมายและเผ็ดร้อนหรือแม้แต่ฟังก์ชั่นที่เราสร้างขึ้นเอง ในการดำเนินการนี้ ขั้นแรกเราต้องใช้จุดพิกัด x และ y หลายจุด จากนั้นป้อนจุดเหล่านั้นลงในอาร์เรย์ตัวเลขสองตัว จากนั้นจึงใช้ฟังก์ชันพล็อต(). เป็นตัวอย่างเบื้องต้น เราจะวาดเส้นโค้งบาปโดยใช้ Code4

1 #Code4: ฟังก์ชันการลงจุด
2 นำเข้าตัวเลขเป็น np
3 นำเข้า matplotlib pyplot เป็น plt
4 #
5 x = np.arange (0, 6.4, 0.1);
6 ปี = np.sin(x)
7 พล็อต.พล็อต(x, y)
8 plt.show( )

ในบรรทัดที่ 2 เรานำเข้ามากมายเช่นnp. ในแถวที่ 5 เราสร้างแถวxประกอบด้วย 64 หมายเลข 0, 0.1, 0.2, ..., 6.3. ในบรรทัดที่ 6 เราสร้างอาร์เรย์ประกอบด้วยค่า 64 ค่ายี่ = บาป (xi). ในบรรทัดที่ 7 เราทำโครงเรื่องเทียบกับxและในบรรทัดที่ 8 เราจะแสดงพล็อตบนหน้าจอคอมพิวเตอร์ ดังแสดงในรูปที่ 4 พล็อตนี้สามารถปรับปรุงได้โดยใช้ฟังก์ชัน pyplot เพิ่มเติม Code4 เวอร์ชันที่แก้ไขเล็กน้อยอยู่ด้านล่าง

1 #Code5: เพิ่มองค์ประกอบกราฟิก
2 นำเข้าตัวเลขเป็น np
3 นำเข้า matplotlib.pyplot เป็น plt
4 #
5 x = np.arange(0, 6.4, 0.1);
6 ปี = np.sin(x)
7 พล็อต.พล็อต(x, y)
8 plt.grid(จริง)
9 plt.xticks(ขนาดตัวอักษร=14)
10 plt.yticks( ขนาดตัวอักษร=14)
11 plt.ylabel(r'$\sin(x)$', ขนาดตัวอักษร=24)
12 plt.xlabel(r'$x/{\rm_rad}$', ขนาดตัวอักษร=24)
13 plt.tight_layout()
14 plt.savefig(’SineGrid.eps ’, รูปแบบ=’eps’ ,\
15 จุดต่อนิ้ว = 1,000)
16 plt.show()
การสร้างกราฟด้วย Matplotlib ใน Python (5)
การสร้างกราฟด้วย Matplotlib ใน Python (6)
  • บรรทัดที่ 8 เพิ่มตารางลงในโครงเรื่อง
  • บรรทัดที่ 9 และ 10 เปลี่ยนขนาดแบบอักษรเริ่มต้นของมาตราส่วน x และ y ในตารางตามลำดับ
  • บรรทัดที่ 11 และ 12 เพิ่มป้ายกำกับสำหรับแกน y และ x ของโครงเรื่องตามลำดับ ป้ายกำกับเหล่านี้ต้องอยู่ในเครื่องหมายคำพูดเดี่ยวหรือคู่ (“หรือ”) ป้ายกำกับอาจเป็นข้อความธรรมดา แต่สามารถใช้ข้อความ LATEX ที่ล้อมรอบด้วยเครื่องหมาย $ ได้เช่นกัน ในกรณีนี้ สตริงข้อความต้องขึ้นต้นด้วย r r ที่ด้านหน้ามีความสำคัญ เนื่องจากเป็นการส่งสัญญาณว่าสตริงนั้นเป็นสตริงดิบ โดยที่อักขระ เช่น แบ็กสแลชจะไม่ถูกตีความว่าเป็นอักขระหลีกของ Python สามารถระบุขนาดตัวอักษรของฉลากได้อีกครั้ง ขอแนะนำให้ทดลองขนาดตัวอักษรที่แตกต่างกันเล็กน้อยในบรรทัดที่ 9–13 เพื่อให้ได้ผลลัพธ์ที่สวยงาม
  • แถวที่ 13 ปรับเค้าโครงรูปภาพเพื่อรวมเครื่องหมายตารางและป้ายกำกับ: จากการทดลอง ดูว่าเกิดอะไรขึ้นหากคุณย้ายแถวที่ 13 ไปหลังแถว 8 หรือ 9 โดยตรง
  • บรรทัดที่ 14–15 สร้างรูปภาพ PostScript แบบห่อหุ้มชื่อ 'SineGrid.eps' รูปแบบที่รองรับสำหรับภาพที่ส่งออกคือ .png, .pdf, .ps, .eps และ .svg ผลลัพธ์แสดงในรูปที่ 5

สคริปต์ Python เดียวสามารถสร้างตัวเลขเดียวที่ประกอบด้วยพล็อต (พล็อตย่อย) ที่แยกจากกันมากกว่าหนึ่งอัน ตัวอย่างแสดงใน Code6

1 # รหัส 6:
2 นำเข้า matplotlib pyplot เป็น plt
3 นำเข้าตัวเลขเป็น np
4
5 def fun1(t,โอเมก้า,เทา,แอมเพิล):
6 y=ampl∗np.cos (โอเมก้า∗t)∗np.exp(−t/tau)
7 กลับ ย
8 def fun2(t,โอเมก้า,โอเมก้า2,แอมเพิล):
9 y=ampl∗np.sin(omega2∗t)∗np.sin(โอเมก้า∗t)
10 ผลตอบแทนปี
11 #

บรรทัดที่ 5–7 และ 8–10 กำหนดสองฟังก์ชันfun1(t, โอเมก้า, เทา, แอมป์)และfun2(t, โอเมก้า, โอเมก้า 2, แอมป์)ในรูปแบบทางคณิตศาสตร์ได้แก่

การสร้างกราฟด้วย Matplotlib ใน Python (7)
12 โอเมก้า=32.0
13 โอเมก้า2=np. ปี่/2.0
14 = 1.0
15 แอมป์=5.0
16 แอมป์2=10.0

บรรทัดที่ 12–16 ให้ค่าตัวเลขแก่พารามิเตอร์ของทั้งสองฟังก์ชัน f1 และ f2 ใน (3.1) ได้แก่ ω = 32, ω2 = π/2, τ = 1.0, A = 5.0 และ B = 10.0

17 t=np. จัดเรียง (0.0 , 2.0, 0.01)
18 s1=fun1(t ,โอเมก้า, เทา ,ampl)
19 s2=fun2(t ,โอเมก้า,โอเมก้า2,ampl2)
20 # ............................................
21 พ.ย. รูป ( รูปขนาด =(10,4))
  • บรรทัดที่ 17 สร้างอาร์เรย์ t ประกอบด้วยตัวเลข 200 ตัว [0.00, 0.001, 0.002,…,0.199] ที่จะใช้เป็นแกน x สำหรับพล็อต บรรทัดที่ 18 และ 19 สร้างอาร์เรย์ s1 และ s2 สองตัว ซึ่งใช้เป็นแกน y ในโครงเรื่อง
  • บรรทัดที่ 21 สร้างภาพที่กว้าง 3.10 นิ้วและสูง 4 นิ้ว ค่าสัมบูรณ์ (หรือหน่วย) นั้นไม่เกี่ยวข้องจริงๆ เนื่องจากรูปภาพจะถูกปรับขนาดทั้งบนหน้าจอคอมพิวเตอร์และเมื่อพิมพ์ แต่อัตราส่วนความกว้าง/ความสูงมีความเกี่ยวข้อง
22 # ................................... แผนย่อย 1
23 พ.ย. แผนย่อย (1,2,1)
24 พ.ย. โครงเรื่อง (t , s1)
25 แผ่น พล็อต (t ,ampl∗np.exp(−t /tau ))
26 พ.ย. ตาราง (จริง)
27 พ.ย. xticks ( ขนาดตัวอักษร=14)
28 พ.ย. yticks ( ขนาดตัวอักษร=14)
29 พ.ย ylabel(r'$A\,\cos(\omegat)\,{\rm e}^{−t /\tau}$', ขนาดตัวอักษร=24)
30 แผ่น xlabel ( r '$t$ ' , ขนาดตัวอักษร=24)
31 พ.ย. แน่น_เค้าโครง ( )
  • บรรทัดที่ 23 สร้างแผนย่อยแรก อาร์กิวเมนต์ 1, 2, 1 ของฟังก์ชันแผนย่อย () ระบุ 1 แถวและ 2 คอลัมน์สำหรับตัวเลขโดยรวม เพื่อให้แผนย่อย 2 รายการวางเคียงข้างกันในแถวเดียว อาร์กิวเมนต์สุดท้าย 1 ระบุว่าสิ่งต่อไปนี้จะถูกวาดในแผนย่อยแรก (ซ้าย)
  • บรรทัดที่ 24 พล็อตอาร์เรย์ s1 กับอาร์เรย์ t เช่น f1 กับ t
  • บรรทัดที่ 25 เพิ่มพล็อตของเอ็กซ์โปเนนเชียล A e−t/τ เทียบกับ t ส่วนที่เหลือจะคล้ายคลึงกับบรรทัดที่ 8–13 ของ Code5 แปลงที่ทับซ้อนกันสองแปลงแสดงไว้ทางด้านซ้ายของรูปที่ 6
การสร้างกราฟด้วย Matplotlib ใน Python (8)
32 # ................................... แผนย่อย 2
33 พล. แผนย่อย (1,2,2)
34 พ.ย. โครงเรื่อง (t , s2)
35 แผ่น พล็อต (t ,ampl2∗np.sin (omega2∗t ))
36 พ.ย. ตาราง (จริง)
37 พล. xticks ( ขนาดตัวอักษร=14)
38 พล. yticks ( ขนาดตัวอักษร=14)
39 พ.ย. ylabel ( r '$B\ ,\ sin (\omega t )\ ,\ sin (\omega_2 t )$' , ขนาดตัวอักษร=24)
40 แผ่น xlabel ( r '$t$ ' , ขนาดตัวอักษร=24)
41 พ.ย. แน่น_เค้าโครง ( )
42 #
  • บรรทัดที่ 33 สร้างแผนย่อยที่สองซึ่งอยู่ในคอลัมน์ที่สองของแถวแรก (และเท่านั้น) ของรูปภาพคือทางด้านขวา
  • บรรทัดที่ 34 พล็อตอาร์เรย์ s2 กับอาร์เรย์ t เช่น f2 กับ t
  • บรรทัดที่ 35 เพิ่มพล็อตของบาป ω_2t) กับ t เส้น
  • 36–41 เพิ่มป้ายตารางและแกน และปรับขนาดตัวอักษร พล็อตจะแสดงทางด้านขวาของรูปที่ 6 รูปภาพในรูปแบบ Encapsulated PostScript ถูกสร้างขึ้น และสองพล็อตถูกแสดงบนหน้าจอ
43 พล. savefig ( 'MultiPlot0 .eps ' , รูปแบบ='eps ' , dpi=1000)
44 plt .show( )

รูปภาพในรูปแบบ “Encapsulated PostScript” (EPS) จะถูกสร้างขึ้น และสองพล็อตจะแสดงบนหน้าจอ

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

1 # Code7: ลอการิทึมกราฟพล็อต
2 นำเข้า matplotlib.pyplot เป็น plt
3 นำเข้าตัวเลขเป็น np
4#. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ฟังก์ชั่น
5 x=np.arange (1.0 ,20.5 ,1.0)
6 y1=x∗∗2
7 y2=np.sqrt(x)

บรรทัดที่ 5 สร้างอาร์เรย์ x = [1,0, 2,0, …, 20,0] บรรทัดที่ 6 และ 7 สร้างอาร์เรย์ y1 และ y2 โดยที่ y(1)_i = x²_i และ y(2)_i = √x_i

8 # ........................................
9 รูป(figsize=(10,8))

ปฏิบัติตามหลักการเดียวกันกับบรรทัดที่ 21 ใน Code6 ขอย้ำอีกครั้งว่าสามารถปรับได้เฉพาะอัตราส่วนความกว้าง/ความสูงโดยรวมของรูปภาพเท่านั้น

10 # ................................... แผนย่อย 1
11 พล็อตย่อย (2,2,1)
12 plt.plot(x,y1, 'ro')
13 plt.plot(x,y2, 'bo')
14 plt.grid(จริง)
15 plt.xticks(ขนาดตัวอักษร=14)
16 plt.yticks(ขนาดตัวอักษร=14)
17 plt.xlabel('เชิงเส้น' , ขนาดตัวอักษร=16)
18 plt.ylabel('เชิงเส้น' , ขนาดตัวอักษร=16)
19 plt.tight_layout ()
20 พิลท์.อิลิม(−10,420)
21 plt.xlim(0,21)
  • นี่คือแผนย่อยแรกจากสี่แผนย่อย (ทบทวนรูปที่ 7) ซึ่งอยู่ที่ตำแหน่งแรก (1, 1) หรือมุมซ้ายบนของอาร์เรย์พล็อต 2 × 2 ของเราที่แสดงในรูปที่ 7 ทั้งสี่แปลงแสดงข้อมูลเดียวกัน กล่าวคือ y1 กับ x ถูกเขียนทับด้วย y2 กับ x ข้อมูล y1 จะแสดงด้วยวงกลมสีแดง ในขณะที่ข้อมูล y2 จะแสดงด้วยวงกลมสีน้ำเงินในทุกแปลง ในพล็อตแรกนี้ ทั้งสเกล x และ y เป็นแบบเชิงเส้น และผลลัพธ์ของสแควร์รูทข้อมูลจะแบนราบมาก
  • บรรทัดที่ 20 และ 21 กำหนดขีดจำกัดของค่า x และ y โดยขยายค่าเริ่มต้นเล็กน้อย สิ่งนี้ทำเพื่อให้วงกลมเป็นตัวแทนของจุดข้อมูลที่รุนแรงภายในกรอบการลงจุด จากการทดลอง ดูว่าเกิดอะไรขึ้นหากคุณแสดงความคิดเห็นในบรรทัดเหล่านี้
22 # ................................... แผนย่อย 2
23 พล็อตย่อย (2,2,2)
24 plt.plot(x,y1, 'ro')
25 plt.plot(x,y2, 'bo')
26 plt.grid(จริง)
27 plt.yscale('บันทึก')
28 plt.xticks(ขนาดตัวอักษร=14)
29 plt.yticks(ขนาดตัวอักษร=14)
30 plt.xlabel('เชิงเส้น' , ขนาดตัวอักษร=16)
31 plt.ylabel(r '$\log$ ' , ขนาดตัวอักษร=20)
32 plt.tight_layout ()
33 แต้ม (0.8,500)
34 ไพลต.xlim(−0.8,21)

นี่คือแผนย่อยที่สอง (มุมขวาบน) บรรทัดที่ 27 สร้างลอการิทึมมาตราส่วน y ด้วยตัวเลือกนี้ พล็อตรากที่สองจะไม่แบนอีกต่อไป โปรดจำไว้ว่าเมื่อคุณใช้สเกลลอการิทึม ควรหลีกเลี่ยงค่าพิกัดลบและศูนย์ หากคุณต้องการค่าพิกัดลบ คุณสามารถแทนที่บรรทัด 27 ได้plt.yscale(สัญลักษณ์), ที่ไหน'สัญลักษณ์'เป็นตัวย่อของลอการิทึมสมมาตร การทำงานสัญลักษณ์()กำหนดเป็น:

การสร้างกราฟด้วย Matplotlib ใน Python (9)

ดังนั้นการพล็อตจะกลายเป็นเส้นตรงในช่วง −ythr ≤ y ≤ ythr โดยหลีกเลี่ยงภาวะเอกฐานลอการิทึมที่ y = 0 ตามค่าเริ่มต้น ythr = 2 แต่คุณสามารถเปลี่ยนค่านี้เป็น ตัวอย่างเช่น 0.1 ได้โดยเปลี่ยนบรรทัด 27 ดังนี้ : :

27 พ.ย. yscale ( 'สัญลักษณ์' ,linthreshy =0.1)

ค่าคงที่ α ในสมการข้างต้นถูกกำหนดเป็น α = log(ythr)/ythr ดังนั้นสัญลักษณ์ (y) จะต่อเนื่องกันที่ y = ±ythr

35 # ................................... แผนย่อย 3
36 พล็อตย่อย (2,2,3)
37 plt.plot(x,y1,'ro')
38 plt.plot(x,y2,'bo')
39 plt.grid(จริง)
40 plt.xscale('บันทึก')
41 plt.xticks(ขนาดตัวอักษร=14)
42 plt.yticks(ขนาดตัวอักษร=14)
43 plt.xlabel(r '$\log$' , ขนาดตัวอักษร=20)
44 plt.ylabel('เชิงเส้น' , ขนาดตัวอักษร=16)
45 plt.tight_layout()
46 พิลท์.อิลิม(−10.8,420)
47 plt.xlim(0.8,22)

นี่คือแผนย่อยที่สาม (มุมซ้ายล่าง) บรรทัดที่ 40 สร้างลอการิทึมมาตราส่วน x ในขณะที่มาตราส่วน y ยังคงเป็นเส้นตรง ในกรณีที่มีค่า x เป็นศูนย์หรือเป็นลบ ลอการิทึมสามารถถูกแทนที่ด้วยฟังก์ชันได้สัญลักษณ์()ซึ่งกำหนดโดยสมการก่อนหน้าด้วยคำสั่งต่อไปนี้:

48 # ................................... แผนย่อย 4
49 พล็อตย่อย (2,2,4)
50 plt.plot(x,y1,'ro')
51 plt.plot(x,y2,'bo')
52 plt.grid(จริง)
53 plt.xscale('บันทึก')
54 plt.yscale('บันทึก')
55 plt.xticks(ขนาดตัวอักษร=14)
56 plt.yticks(ขนาดตัวอักษร=14)
57 plt.xlabel(r'$\log$' , ขนาดตัวอักษร=20)
58 plt.ylabel(r'$\log$' , ขนาดตัวอักษร=20)
59 plt.tight_layout ()
60 ไพลิน (0.8,500)
61 plt.xlim(0.8,25)
การสร้างกราฟด้วย Matplotlib ใน Python (10)

ต่อไปนี้เป็นแผนย่อยที่สี่ (มุมขวาล่าง) เส้นที่ 53 และ 54 ปรับขนาดแกนทั้งสองเป็นลอการิทึม วงกลมที่เป็นตัวแทนของข้อมูลทั้งสองชุดอยู่บนเส้นตรงเพราะเรามี

การสร้างกราฟด้วย Matplotlib ใน Python (11)
62 #
63 plt.savefig('LogPlot0.eps',format='eps', dpi=1000)
64 plt.show()

ในส่วนนี้ เราจะพูดถึงวิธีการวาดเส้นสนาม โดยเฉพาะวิธีการวาดเส้นสนามจากไดโพลไฟฟ้า ไดโพลของเราประกอบด้วยสองประจุ +q และ -q ซึ่งอยู่ที่ (0, +h) และ (0, -h) ในกรอบอ้างอิงคาร์ทีเซียน ดังแสดงในรูปที่ 8 การขยายสำหรับเส้นสนามที่สร้างโดยการกำหนดค่าประจุ ซึ่งซับซ้อนกว่า

การสร้างกราฟด้วย Matplotlib ใน Python (12)
  • วิธีสร้างเส้นสนามไฟฟ้าจากประจุทั้งสอง ±q ที่ P0 ควรจะค่อนข้างง่าย แนวคิดคือการใช้วิธีการที่คล้ายคลึงกับวิธีของออยเลอร์ในการแก้สมการเชิงอนุพันธ์สามัญ กล่าวอีกนัยหนึ่ง เราประมาณเส้นสนามแต่ละเส้นด้วยรูปหลายเหลี่ยมที่ประกอบด้วยส่วนของเส้นตรงที่สั้นมากและมีความยาวเท่ากัน รูปหลายเหลี่ยมแต่ละรูปเริ่มต้นจากจุดกำเนิด P0 ≡ (x0, y0) ซึ่งอยู่ติดกัน แต่เห็นได้ชัดว่าไม่ใช่เรื่องบังเอิญ โดยมีประจุ ±q หนึ่งในสองประจุที่สร้างสนามไฟฟ้า
  • หลังจากเลือกจุดเริ่มต้น P0 ของเส้นสนามแล้ว เราจะประเมินสนามไฟฟ้า E0 ภายในนั้น สิ่งที่เกี่ยวข้องกับวิธีการของเราไม่ใช่ความเข้มของสนามแม่เหล็ก แต่มีเพียงทิศทางเท่านั้น ซึ่งก่อให้เกิดมุม γ0 = อาร์คแทน (E0y/E0x) ซึ่งเป็นค่าลบในกรณีของรูปที่ 8 เทียบกับทิศทาง x หลังจากกำหนดมุม γ0 แล้ว เราจะเลือกความยาวเล็กน้อย δl ซึ่งจะเป็นความยาวทั่วไปของส่วนของเส้นเดี่ยวทั้งหมดที่ก่อตัวเป็นรูปหลายเหลี่ยมที่ใกล้เคียงกับเส้นสนาม โดยทั่วไปอาจต้องใช้การทดลองเพื่อหาค่า δl ที่เหมาะสมที่สุด
  • จุดที่สองของรูปหลายเหลี่ยมของเราคือจุด P1 ≡ (x1, y1) = (x0 + δl cos γ0, y0 + δl sin γ0) ขั้นตอนต่อไปคือการประเมินสนามไฟฟ้า E1 ที่ P1 และมุม γ1 ด้วยทิศทาง x ซึ่งเป็นตัวกำหนดจุด P2 ขั้นตอนนี้ทำซ้ำเพื่อค้นหาจุด Pm ถัดไปของรูปหลายเหลี่ยม เราจะหยุดเมื่อรูปหลายเหลี่ยมเข้าใกล้โหลดอื่นหรือเมื่อรูปหลายเหลี่ยมออกไปนอกพื้นที่พล็อตที่ต้องการ ขั้นตอนที่เป็นไปได้สามารถดูได้ใน Code8
1 # Code8: แปลงเมดาไดโพล
2 นำเข้า matplotlib pyplot เป็น plt
3 นำเข้าตัวเลขเป็น np
4#. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . สถานที่ชาร์จ
5 บวก=1.0
6 y ลบ=−1.0
7 xplus=xลบ=0.0
8 ราด=0.1
9 ลิม=30
10 นลิน=60
11 จุดแกน('ปิด')

ตัวแปรเอ็กซ์พลัส(xminus) และใช่แล้ว(หลังจาก) คือพิกัด x และ y ของประจุบวก (ลบ) ในไดโพลในหน่วยใดก็ได้ ตัวแปรราดคือรัศมีของวงกลมรอบประจุบวก +q จากจุดที่เส้นสนามของเราเริ่มต้น ดูรูปที่ 9 การประเมินเส้นหยุดถ้าสนามเมื่อพิกัด x หรือ y ของจุดปัจจุบันมากกว่าลิมหรือเล็กกว่า-ลิม. ดีราดและลิมแสดงในหน่วยตามอำเภอใจเช่นเดียวกับเอ็กซ์พลัส,xminus,ใช่แล้ว, และหลังจาก. ตัวแปรนลินคือจำนวนเส้นสนาม n เส้นที่เริ่มต้นจากประจุบวก บรรทัดที่ 11 ลบแกนออกจากรูปภาพ

12#. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . เส้นสนาม
13 ผม=0
14 เดลต้า=0.05

ตัวแปรฉันเป็นตัวนับเส้นสนามในขณะที่เดลต้าคือความยาว δl ของส่วนของเส้นตรง

15 ในขณะที่ i16 รายการ =[]
17 รายการ =[]
18 alpha0=i∗2∗np.pi/float(nLin)
19 x=xplus+rad∗np.cos(อัลฟา0)
20 y=yplus+rad∗np.sin(alpha0)
21 xlist.ผนวก(x)
22 ylist.ผนวก(y)
23 ในขณะที่จริง:
24 alpha=np.arctan2(y−yplus),(x−xplus))
25 เบต้า=np.arctan2((y−yminus), (x−xminus))
26 อีพลัส=1.0/((x−xplus)∗∗2+(y−yplus)∗∗2)
27 ระยะห่าง=−1.0/((x−xลบ)∗∗2+(y−yลบ)∗∗2)
28 Ex=Eplus∗np.cos(อัลฟา)+Eminus∗np.cos(เบต้า)
29 Ey=Eplus∗np.sin(อัลฟา)+Eminus∗np.sin(เบต้า)
30 gamma=np.arctan2 (Ey,Ex)
31 x=x+เดลต้า∗np.cos(แกมมา)
32 y=y+เดลต้า∗np.sin(แกมมา)
33 ถ้า x>lim หรือ x<−lim หรือ y>lim หรือ y<0:
34 พัก
35 xlist.ผนวก(x)
36 ylist.ผนวก(y)
37 plt.plot(xlist, ylist, ’k−’,linewidth=0.5)
38 ylist=−np.array(ylist)
39 plt.plot(xlist, ylist, ’k−’,linewidth=0.5)
40 ไอ+=1
  • ในลูปที่ 15–40 จะมีการวาดเส้นฟิลด์หนึ่งเส้นในการวนซ้ำแต่ละครั้ง
  • เส้นที่ 16 และ 17 แสดงรายการ (ว่างในตอนแรก) พิกัด x และ y ของจุดยอดของรูปหลายเหลี่ยมที่ใกล้เคียงกับเส้นสนาม มุม alpha0, α0 = 2πi/n (โดยที่ n คือจำนวนเส้นสนามที่วาด) ซึ่งกำหนดไว้ในบรรทัดที่ 18 และแสดงในรูปที่ 3.9 จะกำหนดตำแหน่งของจุดเริ่มต้น P0 ของเส้นสนามปัจจุบัน เส้นสนามทั้งหมดเริ่มต้นจากจุดที่เว้นระยะห่างเท่าๆ กันรอบๆ วงกลมเล็กๆ ที่มีรัศมี rad (r ในรูป) โดยมีศูนย์กลางอยู่ที่ประจุบวก +q พิกัด x และ y ของ P0 ได้รับการประเมินที่
  • บรรทัดที่ 19 และ 20 ตามลำดับ และแทรกลงใน xlist และ ylist บนบรรทัดที่ 21 และ 22
  • การทำซ้ำ 23–36 ประเมินจุดมุมต่อเนื่องของเส้นสนาม Pm ดังแสดงในรูปที่ 10
  • ตัวแปรอัลฟ่าและเบต้าในบรรทัดที่ 24 และ 25 คือมุม αm และ βm ดังแสดงในรูปที่ 10
  • เส้นที่ 26–29 คำนวณส่วนประกอบ x และ y ของสนามไฟฟ้า Em ที่ Pm และเส้น 30 คำนวณมุม γm ที่ Em สร้างด้วยแกน x
  • เส้นที่ 31 และ 32 คำนวณพิกัดของจุดถัดไปของ “รูปหลายเหลี่ยมภูมิประเทศ” Pm+1
  • บรรทัดที่ 33 และ 34 จะหยุดการวนซ้ำหากมีพิกัด x หรือ y อยู่นอกช่วงที่ต้องการ ยอมรับเฉพาะพิกัด y บวกเท่านั้น เนื่องจากเราสามารถใช้ประโยชน์จากสมมาตรกระจกของรูปภาพรอบแกน x ได้
  • เส้นที่ 37 ลากเส้นสนามที่ครึ่งบนของระนาบ y > 0
  • บรรทัดที่ 38 เปลี่ยนเครื่องหมายของ ylist และบรรทัดที่ 39 วาดเส้นสนามแบบสมมาตรที่ครึ่งล่างของสนาม
การสร้างกราฟด้วย Matplotlib ใน Python (13)
การสร้างกราฟด้วย Matplotlib ใน Python (14)
การสร้างกราฟด้วย Matplotlib ใน Python (15)
  • จุดมุมตามลำดับของเส้นสนาม Pm ดังแสดงในรูปที่ 10
  • ตัวแปรอัลฟ่าและเบต้าในบรรทัดที่ 24 และ 25 คือมุม αm และ βm ในรูปที่ 10
  • เส้นที่ 26–29 คำนวณส่วนประกอบ x และ y ของสนามไฟฟ้า Em ที่ Pm และเส้น 30 คำนวณมุม γm ที่ Em สร้างด้วยแกน x
  • เส้นที่ 31 และ 32 คำนวณพิกัดของจุดถัดไปของ “รูปหลายเหลี่ยมภูมิประเทศ” Pm+1
  • บรรทัดที่ 33 และ 34 จะหยุดการวนซ้ำหากมีพิกัด x หรือ y อยู่นอกช่วงที่ต้องการ ยอมรับเฉพาะพิกัด y บวกเท่านั้น เนื่องจากเราสามารถใช้ประโยชน์จากสมมาตรกระจกของรูปภาพรอบแกน x ได้
  • เส้นที่ 37 ลากเส้นสนามที่ครึ่งบนของระนาบ y > 0
  • บรรทัดที่ 38 เปลี่ยนเครื่องหมายของ ylist และบรรทัดที่ 39 วาดเส้นสนามแบบสมมาตรที่ครึ่งล่างของสนาม
41 # ................................................ ....................
42 plt.savefig('DipoleField.pdf', format='pdf')
43 plt.show()

บรรทัดที่ 42 บันทึกพล็อตเป็นไฟล์ pdf ด้วยชื่อ DipoleField.pdf ซึ่งแสดงในรูปที่ 11

ไลบรารี matplotlib ให้ความเป็นไปได้ในการสร้างภาพเคลื่อนไหวบนหน้าจอคอมพิวเตอร์ วิธีที่ง่ายที่สุดคือการใช้คลาสแอนิเมชั่นหนึ่งในสองคลาสต่อไปนี้:

  1. FuncAnimation: สร้างภาพเคลื่อนไหวโดยการเรียกใช้ฟังก์ชันที่กำหนดซ้ำๆฟังก์ชั่น().
  2. ArtistAnimation: ภาพเคลื่อนไหวนี้ใช้ชุดวัตถุศิลปินคงที่

ในบริบทนี้ เราจะพิจารณาเฉพาะชั้นเรียนเท่านั้นFuncAnimationซึ่งน่าสนใจกว่าสำหรับนักฟิสิกส์ เป็นตัวอย่างง่ายๆ เราจะเขียนสคริปต์ที่แสดงพล็อตไซน์เอ็กซ์โพเนนเชียลที่ได้รับผลกระทบในแนวนอน (การแพน)

1 # Code9: ภาพเคลื่อนไหว Pyplot
2 #
3 นำเข้าตัวเลขเป็น np
4 นำเข้า matplotlib.pyplot เป็น plt
5 นำเข้า matplotlib.animation เป็นภาพเคลื่อนไหว
6 #
7 รูป,ขวาน=plt.subplots(รูปขนาด =(10,6))
8 ax.set(ylim=(−1,1))
9 #
  • บรรทัดที่ 7 สร้างภาพที่มีขนาด 10 × 6 นิ้ว โดยมีหนึ่งแผนย่อยที่เรียกว่า 'ขวาน'
  • บรรทัดที่ 8 กำหนดขอบเขตแกน y ของแผนย่อยนี้ นี่เป็นสิ่งจำเป็นเพื่อป้องกันไม่ให้ pyplot เปลี่ยนสเกลของแกนตั้งของพล็อตเมื่อแอมพลิจูดของฟังก์ชันที่แสดงลดลง
ฟังก์ชั่น 10 def (x):
11 ส่งคืน np.sin(8∗x)∗np.exp(−0.1∗x)
12 #
13 x=np.arange(0,10,0.01)
14 เส้น=ขวาน โครงเรื่อง (x, func (x))
15 #
  • บรรทัดที่ 10–11 กำหนดฟังก์ชัน f(x) = sin(8x) e^(-0.1x) ซึ่งเราจะพล็อต
  • บรรทัดที่ 13 เก็บค่าเริ่มต้น 100 ค่าของ x ที่ฟังก์ชันจะประเมิน ได้แก่ [0, 0.01, 0.02, …, 9.99] ลงในรายการ x
  • บรรทัดที่ 14 สร้างวัตถุ 'line' ซึ่งอยู่ในคลาส 'matplotlib.lines.Line2D' ในแผนย่อย 'ax' วัตถุ 'line' มีรายการ 'x' เป็น 'xdata' และรายการ 'func(x)' เป็น 'ydata'
ภาพเคลื่อนไหว 16 รายการ (i):
17xx=x+i/100
18 บรรทัด set_xdata(xx)
19 line.set_ydata(ฟังก์ชั่น(xx))
20 ax.set(xlim=(xx[0],xx[999]))
21 เส้นกลับ,
22 #
  • บรรทัดที่ 16–21 กำหนดฟังก์ชันเคลื่อนไหว()ซึ่งอัปเดตโครงเรื่องในแต่ละ 'เฟรม' ของภาพเคลื่อนไหว ฟังก์ชันนี้มีหนึ่งอาร์กิวเมนต์ฉันซึ่งจะเพิ่มขึ้น 1 ในแต่ละขั้นตอนของภาพเคลื่อนไหว
  • บรรทัดที่ 17 สร้างรายการxxซึ่งมีองค์ประกอบที่ได้รับจากองค์ประกอบที่เกี่ยวข้องของรายการต้นฉบับxโดยการเพิ่มฉัน/100ในแต่ละองค์ประกอบเหล่านี้
  • บรรทัดที่ 18 และ 19 อัปเดตค่าxและจากวัตถุเส้น, ตามลำดับ.
  • บรรทัดที่ 20 อัปเดตขอบเขตของแกนxจากโครงเรื่อง
  • บรรทัดที่ 21 ส่งคืนวัตถุเส้น.
23 ani=animation.FuncAnimation(รูป, เคลื่อนไหว, ช่วงเวลา=20)
24 plt.show()

บนบรรทัดที่ 23 ฟังก์ชันFuncแอนิเมชั่น()สร้างภาพเคลื่อนไหวโดยการเรียกใช้ฟังก์ชันซ้ำๆเคลื่อนไหว(). อาร์กิวเมนต์บังคับจากFuncแอนิเมชั่น()เป็นสอง: รูปภาพที่จะวาดโครงเรื่องในกรณีของเรารูปที่และฟังก์ชันอัปเดตสำหรับเรื่องนั้นเคลื่อนไหว. การทำงานFuncแอนิเมชั่น()มีอาร์กิวเมนต์ทางเลือกเพิ่มเติมมากมาย ในที่นี้เราใช้เพียงอาร์กิวเมนต์เดียวเท่านั้น กล่าวคือช่วงเวลาเช่น เวลาหน่วงระหว่างเฟรมต่อเนื่องกันในหน่วยมิลลิวินาที ค่าเริ่มต้นคือ 200 ms ที่นี่เราเลือกความล่าช้า 20 ms ผลลัพธ์แสดงในรูปที่ 12

การสร้างกราฟด้วย Matplotlib ใน Python (16)

เมื่อคุณดูที่จอคอมพิวเตอร์จริงๆ แทนที่จะมองภาพบนกระดาษ คุณจะเห็นคลื่นไซน์แบบหมาดเคลื่อนไปทางซ้าย คุณยังสามารถบันทึกภาพเคลื่อนไหวลงในวิดีโอ .mp4 ได้โดยการแทรกบรรทัดani.save('test.mp4', fps=30)ระหว่างบรรทัดที่ 23 และ 24 อาร์กิวเมนต์แรกของani.บันทึก()คือชื่อของไฟล์ mp4 และอาร์กิวเมนต์ที่สองคือจำนวนเฟรมต่อวินาที

นั่นคือทั้งหมดสำหรับคำอธิบาย ขอบคุณ!

อ้างอิง:G. Moruzzi, Python ที่จำเป็นสำหรับนักฟิสิกส์ 2020.

I am an experienced enthusiast in the field of Python programming and data visualization, particularly with the Matplotlib library. I have a deep understanding of the concepts discussed in the provided article about Matplotlib and Pyplot. Now, let's dive into the details of the concepts mentioned:

  1. Matplotlib and Pyplot:

    • Matplotlib: A powerful library in the Python programming language for creating static, animated, and interactive visualizations. It is widely used for data visualization.
    • Pyplot: A component of Matplotlib that provides a collection of functions to simplify the creation of plots. It allows users to create plots with a style similar to MATLAB.
  2. Basic Concepts of Pyplot:

    • Figure: In Matplotlib, a figure is a container that holds all elements of a plot. It serves as a canvas for visualization.
    • Area Plotting: Refers to defining the plotting area within a figure where graphs, lines, and other visual elements will be created.
    • Plotting Lines and Data: Pyplot allows users to plot lines and data within a predefined plotting area.
  3. Adding Labels and Text:

    • Users can add labels (text) to the plot itself or to the horizontal and vertical axes. This helps in explaining the visualization.
  4. Sequential Steps:

    • Pyplot allows users to perform various operations in sequential steps. Changes can be made to the same figure multiple times without losing previous results.
  5. Code Examples:

    • The provided Python code examples demonstrate the usage of Matplotlib and Pyplot to create line plots based on numerical data.
    • Additional features, such as modifying the appearance of the plots using format strings and creating subplots, are also illustrated.
  6. Advanced Plotting:

    • The examples include advanced plotting techniques, such as modifying the appearance of the graph, adjusting font sizes, adding labels, and saving the plots in different formats (e.g., EPS, PDF).
  7. Plotting Functions and Custom Functions:

    • The article demonstrates how to plot various functions, including simple lists of numbers, using Matplotlib. It also highlights the use of NumPy arrays for numerical processing.
    • Custom functions, such as sine and functions involving multiple arrays, are plotted to showcase the flexibility of Matplotlib.
  8. Logarithmic and Logit Scale:

    • Matplotlib supports logarithmic and logit scales for both x and y axes. This is useful when data spans multiple orders of magnitude.
  9. Creating Subplots:

    • The article presents examples of creating subplots, allowing multiple plots to be displayed within a single figure. This is useful for visualizing different aspects of the data simultaneously.
  10. Electric Dipole Field Lines:

    • The article concludes with a more complex example involving the simulation of electric dipole field lines. This includes the use of mathematical computations to determine field vectors and their orientations.

In summary, the article covers a broad range of Matplotlib and Pyplot concepts, from basic plotting to advanced customization and the creation of complex visualizations. The provided Python code snippets offer practical insights into utilizing these features for effective data visualization.

การสร้างกราฟด้วย Matplotlib ใน Python (2024)

References

Top Articles
Latest Posts
Article information

Author: Reed Wilderman

Last Updated:

Views: 6208

Rating: 4.1 / 5 (52 voted)

Reviews: 83% of readers found this page helpful

Author information

Name: Reed Wilderman

Birthday: 1992-06-14

Address: 998 Estell Village, Lake Oscarberg, SD 48713-6877

Phone: +21813267449721

Job: Technology Engineer

Hobby: Swimming, Do it yourself, Beekeeping, Lapidary, Cosplaying, Hiking, Graffiti

Introduction: My name is Reed Wilderman, I am a faithful, bright, lucky, adventurous, lively, rich, vast person who loves writing and wants to share my knowledge and understanding with you.