ការធ្វើផែនការជាមួយ matplotlib

សំណួរសំភាសន៍រចនាប្រព័ន្ធ អាចជាការបើកចំហរ ដូច្នេះវាពិបាកពេកក្នុងការដឹងពីវិធីត្រឹមត្រូវក្នុងការរៀបចំ។ ឥឡូវនេះខ្ញុំអាចបំបែកការរចនានៃ Amazon, Microsoft និង Adobe បន្ទាប់ពីទិញ សៀវភៅ​នេះ. ពិនិត្យឡើងវិញប្រចាំថ្ងៃ សំណួររចនា ហើយខ្ញុំសន្យាថាអ្នកអាចបំបែកការរចនាជុំ។

តើ matplotlib ជាអ្វី?

ពស់ថ្លាន់ ភាសាសរសេរកម្មវិធី និងផ្នែកបន្ថែមគណិតវិទ្យាជាលេខរបស់វា NumPy មានបណ្ណាល័យរៀបចំផែនការរបស់ខ្លួនហៅថា matplotlib. វាផ្តល់នូវ API តម្រង់ទិសវត្ថុ ដែលអ្នកអាចបង្កប់គ្រោងទៅក្នុងកម្មវិធីដោយប្រើប្រអប់ឧបករណ៍ GUI គោលបំណងទូទៅដូចជា Tkinter, wxPython, Qt ឬ GTK+ ។ John D. Hunter ដើមឡើយបានសរសេរ Matplotlib ប៉ុន្តែគាត់បានស្លាប់នៅឆ្នាំ 2012 នៅអាយុ 44 ឆ្នាំ។ ចាប់តាំងពីពេលនោះមក វាជាសហគមន៍អភិវឌ្ឍន៍សកម្មមួយដែលត្រូវបានថែរក្សាដោយអ្នកផ្សេងទៀតជាច្រើន។

ដូចដែលបាននិយាយថា "រូបភាពមានតម្លៃជាងមួយពាន់ពាក្យ" Python មានបណ្ណាល័យដែលមើលឃើញនេះហៅថា matplotlib សម្រាប់ការរៀបចំ 2d នៃអារេ។ ជាមួយនឹង matplotlib អ្នកអាចធ្វើផែនការជាច្រើនដូចជា បន្ទាត់ របារ ខ្ចាត់ខ្ចាយ អ៊ីស្តូក្រាម ជាដើម។

matplotlib គឺជាបណ្ណាល័យដ៏ធំសម្បើមមួយ ហើយការទទួលបានគ្រោងត្រឹមត្រូវត្រូវបានសម្រេចតាមរយៈការសាកល្បង និងកំហុស។ ការបង្កើតគ្រោងជាមូលដ្ឋានគឺជារឿងងាយស្រួលជាង ប៉ុន្តែការមានពាក្យបញ្ជាលើបណ្ណាល័យ matplotlib គឺពិតជាពិបាកណាស់។

ការបង្រៀននេះគឺសម្រាប់អ្នកចាប់ផ្តើមដំបូង ដល់កម្រិតមធ្យម ជាមួយនឹងទ្រឹស្តី និងឧទាហរណ៍ចម្រុះ។ យើងនឹងគ្របដណ្តប់៖

  • pyplot និង pylab
  • គោលគំនិតសំខាន់ៗរបស់ matplotlib
  • plt.subplots()
  • ការមើលឃើញអារេជាមួយ matplotlib
  • គ្រោងជាមួយ pandas និង matplotlib

ហេតុអ្វីបានជា matplotlib មានការភាន់ច្រលំ៖

ទោះបីជាមានឯកសារយ៉ាងសម្បើមនៅលើបណ្ណាល័យ matplotlib ការរៀន matplotlib មិនងាយស្រួលទេដោយសារកត្តាខាងក្រោម៖

  • ដូចដែលបានរៀបរាប់រួចមកហើយ បណ្ណាល័យខ្លួនវាធំណាស់ជាមួយនឹងបន្ទាត់កូដធំៗ។
  • matplotlib មានចំណុចប្រទាក់ជាច្រើន ហើយអាចត្រូវបានរួមបញ្ចូលជាមួយផ្នែកខាងក្រោយផ្សេងៗគ្នាជាច្រើន។ Backend ដោះស្រាយមិនត្រឹមតែរបៀបដែលគំនូសតាងត្រូវបានរៀបចំពីខាងក្នុងប៉ុណ្ណោះទេ ប៉ុន្តែថែមទាំងរបៀបដែលវាត្រូវបានបង្ហាញផងដែរ។
  • ទោះបីជាឯកសារមានលក្ខណៈទូលំទូលាយក៏ដោយ វាហួសសម័យហើយ។ ឧទាហរណ៍ចាស់ៗនៅតែអណ្តែតជុំវិញបណ្ណាល័យដែលកំពុងវិវត្ត។

ចូរយើងសិក្សាពីគោលគំនិតស្នូលនៃការរចនានៃ matplotlib មុនពេលផ្លាស់ទីទៅឧទាហរណ៍។

ភីឡាប៖

Pyplot គឺជាម៉ូឌុល Matplotlib ដែលអ្នកអាចទទួលបានចំណុចប្រទាក់ដូច MATLAB ។ គុណសម្បត្តិមួយក្នុងចំណោមគុណសម្បត្តិរបស់ MATLAB គឺវាអាចអនុវត្តបានទូទាំងពិភពលោក។ មិនដូច Python ការនាំចូលមិនត្រូវបានគេប្រើប្រាស់ច្រើននៅក្នុង MATLAB ទេ។ មុខងារភាគច្រើនរបស់ MATLAB អាចរកបានយ៉ាងងាយស្រួលសម្រាប់អ្នកប្រើប្រាស់នៅកម្រិតកំពូល។

Pylab ប្រមូលផ្តុំថ្នាក់ និងមុខងារពី matplotlib និង NumPy ។ អ្នកដែលធ្លាប់ស្គាល់ MATLAB អាចប្រែប្រួលបានយ៉ាងងាយស្រួលជាមួយ Pylab ព្រោះមិនមានតម្រូវការច្រើនសម្រាប់ការប្រើប្រាស់នាំចូល។ ដោយគ្រាន់តែបន្ថែមបន្ទាត់មួយនេះ

from pylab import *

អតីតអ្នកប្រើប្រាស់ MATLAB អាចហៅ plot() ឬ array() ដូចដែលពួកគេធ្វើនៅក្នុង MATLAB។

ប៉ុន្តែអ្នកប្រើប្រាស់ Python ដឹងថាការប្រើការនាំចូល * គឺជាការអនុវត្តការសរសេរកូដមិនល្អព្រោះវានាំចូលអ្វីគ្រប់យ៉ាងទៅក្នុង namespace ។ ជាលទ្ធផល អ្នកអាចនឹងបញ្ចប់ការសរសេរជាន់លើការភ្ជាប់មកជាមួយ Python ដោយមិនចាំបាច់។ ហើយវាក្លាយជាការលំបាកក្នុងការស្វែងរកកំហុស។ ដូច្នេះ MATLAB ណែនាំកុំឱ្យប្រើការនាំចូល * នៅក្នុងការបង្រៀនរបស់វា។ ជំនួសឱ្យការនាំចូល យើងត្រូវប្រើ %matplotlib ដើម្បីរួមបញ្ចូល IPython ។

កូដប្រភព Pylab ពិតជាបិទបាំងការនាំចូលដែលមានសក្តានុពលជាច្រើន។ ឧទាហរណ៍ ការប្រើប្រាស់ python –pylab នៅក្នុង terminal ឬ បន្ទាត់ពាក្យបញ្ជាឬ %pylab ពិតជាហៅ 'ពីការនាំចូល pylab *' នៅក្រោមក្រណាត់។

ទោះបីជា matplotlib ណែនាំយ៉ាងច្បាស់មិនឱ្យប្រើ pylab ទៀតទេ វានៅតែមាន។ ជំនួសឱ្យការប្រើ pylab យើងអាចប្រើ pyplot ។ pyplot ធ្វើឱ្យ matplotlib ដំណើរការដូច MATLAB ជាមួយនឹងបណ្តុំនៃមុខងាររចនាប័ទ្មពាក្យបញ្ជារបស់វា។

import matplotlib.pyplot as plt

ឋានានុក្រមនៃ matplotlib៖

ឋានានុក្រមវត្ថុគឺជាគោលគំនិតសំខាន់មួយនៃ matplotlib ។ ប្រសិនបើអ្នកបានឆ្លងកាត់ការបង្រៀន matplotlib មួយចំនួនរួចហើយ អ្នកប្រហែលជាបានឆ្លងកាត់បន្ទាត់នេះ៖

plt.plot([1, 2, 3])

វាមើលទៅដូចជាលេខកូដសាមញ្ញមួយ ប៉ុន្តែគ្រោងគឺពិតជាជណ្តើរនៃវត្ថុពស់ថ្លាន់ដែលដាក់សំបុក។ នៅក្រោមគ្រោងនីមួយៗ រចនាសម្ព័ន្ធនៃវត្ថុ matplotlib មាន។

នេះ តួលេខ វត្ថុគឺជាកុងតឺន័រកម្រិតកំពូលសម្រាប់ធាតុគ្រោងទាំងអស់ មានអ័ក្សច្រើន។ អ័ក្សគឺខុសពីអ័ក្ស។ នេះ។ អ័ក្ស គឺជាវត្ថុដែលរក្សាទុកវត្ថុជាច្រើនដូចជា XAxis, Yaxis ហើយយើងអាចបង្កើតគ្រោងដោយហៅវិធីសាស្ត្ររបស់វា។

នៅក្នុងរូបភាពទាំងមូល រូបគឺជាធុងដូចប្រអប់ដែលមានអ័ក្សច្រើន។ នៅក្នុងឋានានុក្រម មានវត្ថុតូចៗដូចជាសញ្ញាធីក បន្ទាត់នីមួយៗ រឿងព្រេង និងប្រអប់អត្ថបទមាននៅខាងក្រោមអ័ក្ស។ ពីធីក និងស្លាក ធាតុនីមួយៗនៅក្នុងគំនូសតាងគឺជាវត្ថុ Python ។

ពិន

តារាងខាងលើគឺជាឧទាហរណ៍នៃឋានានុក្រម matplotlib ។ មិនចាំបាច់បារម្ភទេ ប្រសិនបើអ្នកមិនសូវស្គាល់រឿងនេះទេ យើងនឹងរៀបរាប់នៅក្នុងមេរៀនរបស់យើង។

ប្រសិនបើអ្នកមិនបានដំឡើង matplotlib ទេ សូមដំឡើងវាដោយប្រើពាក្យបញ្ជាខាងក្រោមនៅក្នុងការបង្រៀនរបស់អ្នក។

pip install matplotlib

ប្រតិបត្តិកូដខាងក្រោម៖

import matplotlib.pyplot as plt

figure,_=plt.subplots()
print(type(figure))

plt.subplots() ត្រឡប់ tuple ដែលមានវត្ថុ 2 ។ សម្រាប់ពេលនេះ ចូរយើងខ្វល់តែអំពីវត្ថុទីមួយនៃ tuple ដែលជាវត្ថុរូប។ យើងអាចទាញយកសញ្ញាធីកដំបូងនៃ yaxis នៃវត្ថុអ័ក្សទីមួយដោយខួងចុះតាមឋានានុក្រមនៃរូប។

import matplotlib.pyplot as plt

figure,_=plt.subplots()

# To get first axes of figure
first_axes=figure.axes[0]

# yaxis of first axes object
yaxis=first_axes.yaxis

# first tick of the yaxis of the first axes
first_tick_of_yaxis=yaxis.get_major_ticks()[0]
print(type(first_tick_of_yaxis))

តួលេខនេះមានបញ្ជីអ័ក្ស។ ហើយអ័ក្សនីមួយៗមាន xaxis និង yaxis ដែលពួកវានីមួយៗមានសញ្ញាធីកសំខាន់ៗជាច្រើន។

import matplotlib.pyplot as plt

figure,_=plt.subplots()

axes=figure.axes
print(type(axes))

matplotlib ហៅវាថាជារូបកាយវិភាគសាស្ត្រជាជាងឋានានុក្រមនៃតួលេខ។ អ្នកអាចរកឃើញកាយវិភាគសាស្ត្រនៃរូបគំនូរនៅក្នុងឯកសារផ្លូវការរបស់ matplotlib ។

ពិន

Stateful Vs វិធីសាស្រ្តគ្មានរដ្ឋ៖

មុននឹងផ្លាស់ទីទៅការមើលឃើញ យើងត្រូវយល់ពីភាពខុសគ្នារវាងចំណុចប្រទាក់ដែលមានមូលដ្ឋានលើរដ្ឋ ឬរដ្ឋ និងគ្មានរដ្ឋ ឬចំណុចប្រទាក់តម្រង់ទិសវត្ថុ។

យើងអាចនាំចូលម៉ូឌុល pyplot ពី matplotlib ហើយដាក់ឈ្មោះវាថា plt ដោយវាយពាក្យបញ្ជាខាងក្រោម។

import matplotlib.pyplot as plt

មុខងារទាំងអស់របស់ pyplot ឧទាហរណ៍ plt.plot() សំដៅលើតួលេខ និងអ័ក្សដែលមានស្រាប់។ ប្រសិនបើមិនមានតួលេខ និងអ័ក្សដែលមានស្រាប់ទេ វាបង្កើតថ្មីមួយ។ ដូចដែលបានរៀបរាប់នៅក្នុងឯកសារ matplotlib "[ជាមួយ pyplot] មុខងារសាមញ្ញត្រូវបានប្រើដើម្បីបន្ថែមធាតុគ្រោង (បន្ទាត់ រូបភាព អត្ថបទ។ល។) ទៅអ័ក្សបច្ចុប្បន្ននៅក្នុងតួលេខបច្ចុប្បន្ន"។

ភាពខុសគ្នារវាងចំណុចប្រទាក់គ្មានរដ្ឋ និងគ្មានរដ្ឋ៖

អតីតអ្នកប្រើប្រាស់ MATLAB និយាយថានេះជា “plt.plot() គឺជាចំណុចប្រទាក់របស់រដ្ឋ/state-machine ដែលតាមដានតួលេខបច្ចុប្បន្នដោយប្រយោល។

  • plt.plot() និងមុខងារផ្សេងទៀតរបស់ pyplot នៅកម្រិតកំពូលធ្វើឱ្យការហៅចូលចំណុចប្រទាក់ដែលមានស្ថានភាព។ ដោយសារ plt.plot() សំដៅលើតួលេខ និងអ័ក្សបច្ចុប្បន្ន នៅពេលណាមួយ អ្នកអាចរៀបចំតួរលេខ និងអ័ក្សតែមួយប៉ុណ្ណោះ។ យើងមិនចាំបាច់សំដៅលើវាឱ្យច្បាស់លាស់ទេ។
  • នៅក្នុងវិធីសាស្រ្តតម្រង់ទិសវត្ថុ យើងធ្វើប្រតិបត្តិការខាងលើដោយច្បាស់លាស់ ហើយយើងយកសេចក្តីយោងវត្ថុទៅជាអថេរ ហើយអាចកែប្រែវត្ថុមូលដ្ឋានដោយផ្ទាល់ដោយហៅវិធីសាស្ត្រនៃវត្ថុអ័ក្ស។ វត្ថុអ័ក្សតំណាងឱ្យគ្រោងដោយខ្លួនឯង។

នេះគឺជាឧទាហរណ៍នៃចំណុចប្រទាក់ដែលមានស្ថានភាព៖

plt.plot ()

យើងកំពុងទទួលបានវត្ថុអ័ក្សបច្ចុប្បន្ន។ gca() គឺជាមុខងារមួយនៅទីនេះ មិនមែនជាវិធីសាស្រ្តទេ៖

ax=plt.gca()

នៅក្នុង pyplot មុខងារភាគច្រើនក៏មានជាវិធីសាស្រ្តនៃថ្នាក់ matplotlib.axes.Axes ផងដែរ។ ការហៅវិធីសាស្ត្រ gca នៅលើតួលេខបច្ចុប្បន្ន៖

gcf().gca(**kwargs)

# matplotlib/pyplot.py
>>> def plot(*args, **kwargs):
...     ax = plt.gca()
...     return ax.plot(*args, **kwargs)

>>> def gca(**kwargs):
...     """This returns current axes of the current figure."""
...     return plt.gcf().gca(**kwargs)

plt.plot() ត្រឡប់អ័ក្សបច្ចុប្បន្ននៃតួលេខបច្ចុប្បន្ន។ ចំណុច​ប្រទាក់​ដែល​មាន​លក្ខណៈ​ច្បាស់​លាស់​តាម​ដាន​គ្រោង​ដែល​វា​ចង់​យោង។

នៅក្នុងវិធីសាស្រ្តតម្រង់ទិសវត្ថុ មានវិធីសាស្រ្តទទួល និងកំណត់ដែលត្រូវគ្នា។

ឧទាហរណ៍៖ ax.set_title(), ax.get_title()

ការហៅទូរសព្ទទៅ plt.title() និង gca().set_title() ធ្វើដូចគ្នា។ នេះជាអ្វីដែលវាកំពុងធ្វើ៖

  • gca() ត្រឡប់អ័ក្សបច្ចុប្បន្ន
  • វិធីសាស្ត្រ setter set_title() កំណត់ចំណងជើងសម្រាប់អ័ក្សបច្ចុប្បន្ន។ នៅទីនេះយើងមិននិយាយអំពីវត្ថុអ័ក្សណាមួយទេ។

ដូចគ្នាដែរ អនុគមន៍កម្រិតកំពូលទាំងអស់ plt.grid(), plt.ylabels(), plt.legend(), etc. ធ្វើតាមរចនាសម្ព័ន្ធដូចគ្នានៃការកំណត់អ័ក្សបច្ចុប្បន្នជាមួយ gca() ហើយហៅវិធីសាស្ត្រនៃអ័ក្សបច្ចុប្បន្ន។

plt.subplots():

នៅពេលដែលក្រាហ្វក្លាយជាស្មុគ្រស្មាញ វិធីសាស្រ្តតម្រង់ទិសវត្ថុគឺងាយស្រួល។ ចូរយើងធ្វើផែនការខ្លះដើម្បីយល់ពីគោលគំនិតទាំងនេះ។

ជាមួយនឹង plt.subplots() ក្នុង object-oriented យើងអាចបង្កើត Figure ដែលមានអ័ក្សតែមួយ។ នេះគឺជាកន្លែងតែមួយគត់ដែលយើងបង្កើត Figure និង Axes ជាមួយនឹងវិធីសាស្រ្តតម្រង់ទិសវត្ថុ។

figure,axes=plt.subplots()

plt.subpots() ត្រឡប់តួលេខតែមួយ និងវត្ថុ AxesSubplot តែមួយ។

>>> type(figure)
<class 'matplotlib.figure.Figure'>
>>> type(axes)
<class 'matplotlib.axes._subplots.AxesSubplot'>

ពេលកំពុងហៅ plt.subplots() យើងមិនហៅអាគុយម៉ង់ណាមួយទេ។ នេះ។ អាគុយម៉ង់លំនាំដើម គឺ nrows=1 និង ncols=1។

ដោយសារយើងមានវត្ថុ AxesSubplot យើងអាចហៅវិធីសាស្រ្តរបស់វាស្រដៀងនឹងវិធីដែលយើងហៅមុខងាររបស់ pyplot ។

ក្រាហ្វនៃតំបន់ជង់៖

តោះមើលឧទាហរណ៍នៃក្រាហ្វតំបន់ជង់នៃស៊េរីបីដង។

ដំឡើងលេខដោយវាយពាក្យបញ្ជាខាងក្រោមនៅក្នុងស្ថានីយរបស់អ្នក។

pip install numpy

កូដខាងក្រោមបង្កើតក្រាហ្វ៖

import matplotlib.pyplot as plt
import numpy as np

range=np.arange(50)
rnd=np.random.randint(0,10,size=(3,range.size))
years=1950+range
figure,axes=plt.subplots(figsize=(5,3))
axes.stackplot(years, range + rnd, labels=['Eastasia', 'Eurasia', 'Oceania'])
axes.set_title('Combined debt growth over time')
axes.legend(loc='upper left')
axes.set_ylabel('Total debt')
axes.set_xlim(xmin=years[0],xmax=years[-1])
figure.tight_layout()

plt.show()

នេះជាការពន្យល់សម្រាប់កូដខាងលើ៖

  • np.arange(50)៖ បង្កើតអារេ 1d នៃប្រវែង 50 ជាមួយ លេខរៀង ពី 1 ទៅ 50
  • random.randint(): អនុគមន៍​ត្រឡប់​អារេ​នៃ​រាង​ដែល​បាន​បញ្ជាក់ ហើយ​បំពេញ​ដោយ​លេខ​ចៃដន្យ​ចាប់​ពី​ទាប​ទៅ​ខ្ពស់។ ដែនកំណត់ខ្ពស់បំផុតគឺផ្តាច់មុខ។ ក្នុងករណីរបស់យើង ដែនកំណត់ទាបបំផុតគឺ 0 ដែនកំណត់ខ្ពស់បំផុតគឺ 10 ហើយទំហំគឺ (3, range.size)។ លទ្ធផលនឹងជាអារេ 2d នៃទំហំ 3*50 ដែលបំពេញដោយលេខពី 0 ដល់ 10 (មិនរាប់បញ្ចូល)។
  • យើង​អាច​បញ្ជាក់​ទទឹង​និង​កម្ពស់​របស់​តួលេខ​ក្នុង​ឯកតា “អ៊ីញ” ដោយ​មាន​គុណលក្ខណៈ​ទំហំ​រូប, .
  • stackplot(): វាបង្ហាញផ្នែកនីមួយៗដែលផ្ទុកលើគ្នាទៅវិញទៅមក និងរបៀបដែលផ្នែកនីមួយៗរួមចំណែកក្នុងការបង្កើតតួលេខពេញលេញ។ វាបង្ហាញផ្នែកផ្សេងៗនៃទិន្នន័យ ហើយវាដើរតួដូចជាគំនូសតាងចំណិត។ វាមាន x-label, y-label និងចំណងជើងដែលយើងអាចតំណាងឱ្យផ្នែកផ្សេងៗដែលមានពណ៌ខុសៗគ្នា។
  • set_title(): ដូចឈ្មោះបង្ហាញ វិធីសាស្ត្រកំណត់នេះកំណត់ចំណងជើង។
  • រឿងព្រេង (): ផ្ទៃដែលពិពណ៌នាអំពីធាតុនៃក្រាហ្វ។
  • set_ylabel៖ ស្វែងរកស្លាកសម្រាប់អ័ក្ស y ។
  • set_xlim ៖ កំណត់ដែនកំណត់សម្រាប់អ័ក្ស x ។
  • tight_layout៖ ដើម្បីផ្តល់ឱ្យបន្ទះដែលបានបញ្ជាក់ វាលៃតម្រូវប៉ារ៉ាម៉ែត្រនៃគ្រោងរងដោយស្វ័យប្រវត្តិ។
  • បង្ហាញ៖ បង្ហាញក្រាហ្វ។

នៅទីនេះយើងកំពុងរក្សាទុកវត្ថុអ័ក្សទៅអ័ក្សអថេរ។ តាមរយៈការហៅដោយផ្ទាល់ទៅវិធីសាស្ត្រនៃអ័ក្ស យើងកំពុងបង្កើតគំនូសតាងតំបន់ជាជង់ កំណត់ចំណងជើង បន្ថែមរឿងព្រេង និងកំណត់ស្លាកនៃអ័ក្ស y ។ នេះគឺជាឧទាហរណ៍នៃវិធីសាស្រ្តតម្រង់ទិសវត្ថុ។ នេះជាក្រាហ្វលទ្ធផល៖

ពិន

គ្រោង និងអ៊ីស្តូក្រាម៖

តោះមើលឧទាហរណ៍មួយទៀត ដែលតួលេខមានអ័ក្សច្រើន។ នៅទីនេះយើងនឹងគ្រោងអារេដែលទាក់ទងគ្នាពីរដែលដកចេញពីការចែកចាយឯកសណ្ឋានដាច់ដោយឡែក។

import matplotlib.pyplot as plt
import numpy as np

x = np.random.randint(low=1, high=11, size=50)
y = x + np.random.randint(1, 5, size=x.size)
data = np.column_stack((x, y))
figure, (axes1, axes2) = plt.subplots(nrows=1, ncols=2,figsize=(8, 4))
axes1.scatter(x=x, y=y, marker='o', c='r', edgecolor='b')
axes1.set_title('Scatter: x versus y')
axes1.set_xlabel('x')
axes1.set_ylabel('y')
axes2.hist(data, bins=np.arange(data.min(), data.max()),label=('x', 'y'))
axes2.legend(loc=(0.65, 0.8))
axes2.set_title('Frequencies of x and y')
axes2.yaxis.tick_right()
plt.show()

កូដ​ធ្វើ​កិច្ចការ​ដូច​ខាង​ក្រោម៖

  • នៅទីនេះយើងកំពុងបញ្ជូនប៉ារ៉ាម៉ែត្រទៅ subplots () ដែលបង្កើតតួរលេខតែមួយ និង subplots អ័ក្សពីរ។
  • អថេរ x និង y គឺជាអារេ 1d ដែលបំពេញដោយលេខចៃដន្យ។
  • យើងកំពុងគ្រប់គ្រងវត្ថុអ័ក្សដោយឡែកពីគ្នា។ យើង​កំពុង​បង្កើត​គ្រោង​ដែល​មាន​អ័ក្ស​មួយ​និង​អ៊ីស្តូក្រាម​ជាមួយ​វត្ថុ​អ័ក្ស​ផ្សេងទៀត។
  • tick_right(): មុខងារបង្ហាញចំណុចនៅលើអ័ក្សសំរបសំរួលនៅជ្រុងខាងស្តាំ។

ជាមួយនឹងវិធីសាស្រ្តដែលមានលក្ខណៈរដ្ឋ វាពិតជាលំបាកណាស់ក្នុងការគ្រប់គ្រងវត្ថុអ័ក្សទាំងពីរដោយឡែកពីគ្នា។ ក្រាហ្វលទ្ធផលនឹងមានដូចជា៖

ពិន

អាគុយម៉ង់របស់សញ្ញាសម្គាល់នៅក្នុងអនុគមន៍ខ្ចាត់ខ្ចាយកំណត់រចនាប័ទ្មសម្គាល់ដែលអ្នកអាចផ្លាស់ប្តូរតាមការចង់បានរបស់អ្នក។ នៅទីនេះយើងកំពុងផ្លាស់ប្តូរសញ្ញាសម្គាល់ទៅជា 's' ។

axes1.scatter(x=x, y=y, marker='s', c='r', edgecolor='b')

ហើយ​ដោយ​ការ​ដាក់​អត្ថបទ​នៅ​ខាង​ក្នុង​សញ្ញា​ដុល្លារ​ប្តូរ​អត្ថបទ​ទៅ​ជា​អក្សរទ្រេត។

axes1.set_title('$Scatter$: x versus y')
axes2.set_title('$Frequencies$ $of$ x $and$ y')

លទ្ធផលនឹងដូចជា៖ពិន

ដូចដែលយើងបានឃើញពីមុនមក យើងអាចទទួលបានវត្ថុអ័ក្ស។

>>> figure.axes[0] is axes1 and figure.axes[1] is axes2
True

m * n ក្រឡាចត្រង្គនៃវត្ថុអ័ក្ស៖

ដូចគ្នានេះផងដែរ យើងអាចបង្កើតតួលេខដែលមានវត្ថុអ័ក្សនៅក្នុងក្រឡាចត្រង្គ m*n ។ ឧទាហរណ៍មួយគឺ៖

figure,axes=plt.subplots(nrows=2,ncols=2,figsize=(7,7))

ប្រសិនបើអ្នកពិនិត្យមើលប្រភេទអ័ក្ស វាលែងជា AxesSubplot ទៀតហើយ។ ផ្ទុយទៅវិញ វាជាអារេលេខ។

>>> type(axes)
<class 'numpy.ndarray'>
>>> axes
array([[<matplotlib.axes._subplots.AxesSubplot object at 0x0A4BBAD0>,
        <matplotlib.axes._subplots.AxesSubplot object at 0x0D44F2B0>],
       [<matplotlib.axes._subplots.AxesSubplot object at 0x0D4700F0>,
        <matplotlib.axes._subplots.AxesSubplot object at 0x0D4952D0>]],
      dtype=object)
>>> axes.shape
(2, 2)

អារេ Numpy គឺគ្រាន់តែជាកុងតឺន័រប៉ុណ្ណោះ។ នៅលើវត្ថុអ័ក្សនីមួយៗ យើងត្រូវហៅវិធីសាស្ត្រគ្រោង។ យើងអាចប្រើវិធីសំប៉ែតដើម្បីបំប្លែងអារេ 2d Numpy ទៅជាវត្ថុ 4 ដើម្បីវាយ AxesSubplot ។

axes1,axes2,axes3,axes4=axes.flatten()
>>> type(axes1)
<class 'matplotlib.axes._subplots.AxesSubplot'>

មានវិធីជំនួសដើម្បីធ្វើរឿងនេះ។ ប៉ុន្តែវិធីសាស្រ្តមុនគឺអាចបត់បែនបាន។

((axes1,axes2),(axes3,axes4))=axes

>>> type(axes1)
<class 'matplotlib.axes._subplots.AxesSubplot'>

លក្ខណៈ​ពិសេស​រង​កម្រិត​ខ្ពស់​:

ចូរយើងស្វែងយល់ ដើម្បីយល់ពីលក្ខណៈកម្រិតខ្ពស់មួយចំនួននៃ subplot ជាមួយនឹងឧទាហរណ៍មួយ។ ដោយប្រើបណ្ណាល័យ Python io, urlib និង tarfile យើងនឹងទាញយកទិន្នន័យលំនៅឋានម៉ាក្រូសេដ្ឋកិច្ចពីកាលីហ្វ័រញ៉ាពីបណ្ណសារ tar ដែលបានបង្ហាប់។

import numpy as np
from io import BytesIO
import tarfile
from urllib.request import urlopen

url='https://www.dcc.fc.up.pt/~ltorgo/Regression/cal_housing.tgz'
bytesio_object=BytesIO(urlopen(url).read())
file_path = 'CaliforniaHousing/cal_housing.data'
with tarfile.open(mode='r', fileobj=bytesio_object) as archive:
    housing = np.loadtxt(archive.extractfile(file_path), delimiter=',')

អថេរ url គឺជា URL ដែលផ្ទុកទិន្នន័យ។ កូដខាងលើទាញយកទិន្នន័យចេញពីឯកសារ ហើយរក្សាទុកវាទៅក្នុងអារេ numpy ។

ចូរយើងទទួលបានតម្លៃនៃផ្ទះមធ្យម ចំនួនប្រជាជននៃតំបន់ និងអាយុនៃផ្ទះមធ្យម។

>>> avarage_home_value=housing[:,-1]
>>> population,age=housing[:,[4,7]].T

គុណលក្ខណៈ T គឺគ្មានអ្វីក្រៅពីការផ្ទេរអារេ។

អនុញ្ញាតឱ្យយើងសរសេរមុខងារមួយទៀតដែលដើរតួដូចជា "ចំណងជើងក្នុងគ្រោង" ដោយដាក់ប្រអប់អត្ថបទនៅខាងក្នុងគ្រោងមួយ។

def add_titlebox(axes, text):
    axes.text(.55,.8,text,horizontalalignment='center',
        transform=ax.transAxes,bbox=dict(facecolor='white',alpha=0.6),
        fontsize=12.5)
    return axes

យើង​អាច​ប្ដូរ​គ្រោង​រង​តាម​បំណង​ជាមួយ​នឹង​ម៉ូឌុល gridspec របស់ matplotlib ។ យើងអាចធ្វើអន្តរកម្មជាមួយម៉ូឌុល gridspec ជាមួយ subplot2grid () របស់ pyplot ។ នេះជាប្លង់ដែលយើងនឹងបង្កើត៖

ពិន

នៅទីនេះយើងមានក្រឡាចត្រង្គ 3 * 2 ។ ax1 រួមចំណែកដល់កម្ពស់និងទទឹងពីរដងនៃ ax2 និង ax3 ។

ពិន

ទៅ subplot2grid() យើងកំពុងឆ្លងកាត់ (row, column) ជាអាគុយម៉ង់ដែលគ្មានអ្វីក្រៅពីទីតាំងនៃវត្ថុអ័ក្សនៅក្នុងក្រឡាចត្រង្គ។

gridsize=(3,2)
figure=plt.figure(figsize=(12,8))
ax1=plt.subplot2grid(gridsize, (0, 0), colspan=2, rowspan=2)
ax2 = plt.subplot2grid(gridsize, (2, 0))
ax3 = plt.subplot2grid(gridsize, (2, 1))

ឥឡូវនេះយើងអាចដោះស្រាយជាមួយអ័ក្សនីមួយៗដោយឡែកពីគ្នា។

ax1.set_title("Value of home as a function of age of home and population of area")
scatter=ax1.scatter(x=age,y=population,c=average_home_value,cmap='RdYlGn')
plt.colorbar(scatter,ax=ax1,format='$%d')
ax1.set_yscale('log')
ax2.hist(age,bins='auto')
ax3.hist(population,bins='auto',log=True)

add_titlebox(ax2,'Histogram: Age of the home')
add_titlebox(ax3, 'Histogram: Area population (log scl.)')

plt.show()

វិធីសាស្ត្ររបារពណ៌បន្ថែមរបារពណ៌ទៅគ្រោង។ វាត្រូវបានហៅដោយផ្ទាល់នៅលើតួរលេខ មិនមែននៅលើអ័ក្សទេ។ វាត្រូវចំណាយពេល ax1.scatter() ជាអាគុយម៉ង់ ដែលធ្វើផែនទីតម្លៃផ្ទះជាមធ្យមទៅ ColorMap ។

ពិន

នៅពេលដែលយើងរំកិលឡើងលើ និងចុះក្រោមតាមអ័ក្ស y មិនមានភាពខុសគ្នាច្រើននៅក្នុងពណ៌ទេ។ វាបង្ហាញថាអាយុរបស់ផ្ទះដើរតួនាទីកាន់តែខ្លាំងក្នុងការកំណត់តម្លៃផ្ទះ។

រូបភាព៖

តួលេខអាចត្រូវបានបង្កើតតាមពីរវិធី៖

  • កំពុងហៅ plt.subplots()
  • ការហៅ plt.figure() បង្កើតតួលេខដោយគ្មានអ័ក្ស។ នេះមិនត្រូវបានគេប្រើញឹកញាប់ទេ។

នៅពេលណាដែលយើងអាចបង្កើតតួលេខថ្មី matplotlib រក្សាវានៅក្នុងការចងចាំ។ យើងបានឃើញគោលគំនិតនៃតួលេខបច្ចុប្បន្ន និងអ័ក្សបច្ចុប្បន្ននៅក្នុងចំណុចប្រទាក់ដែលមានស្ថានភាព។ តួរលេខបច្ចុប្បន្ន និងអ័ក្សបច្ចុប្បន្នគឺជារូបដែលទើបបង្កើតថ្មីបំផុត ហើយយើងអាចប្រើមុខងារដែលភ្ជាប់មកជាមួយ ID() ដើម្បីបង្ហាញអាសយដ្ឋានរបស់វត្ថុក្នុងអង្គចងចាំ។

>>> figure1,axes1=plt.subplots()

>>> id(figure1)
162617520
>>> id(plt.gcf())
162617520

>>> figure2,axes2=plt.subplots()

>>> id(figure2)
203096944
#plt.gcf() returns the current figure
>>> id(figure2)==id(plt.gcf())
True
>>>

តួលេខ​ដែល​បង្កើត​ថ្មី​បំផុត​គឺ​តួលេខ​បច្ចុប្បន្ន។ តួលេខទាំងពីរនេះស្ថិតនៅក្នុងអង្គចងចាំ ដែលនីមួយៗត្រូវបានចូលប្រើជាមួយលេខសម្គាល់ដែលត្រូវគ្នា។ ដូចនៅក្នុងរចនាប័ទ្ម MATLAB ការធ្វើលិបិក្រមចាប់ផ្តើមដោយ 1 ។

>>> plt.get_fignums()
[1, 2]

ដោយការគូសផែនទី plt.figure() ទៅនឹងរូបនីមួយៗ យើងអាចទទួលបានតួលេខ។

>>> def get_all_figures():
...     return [plt.figure(i) for i in plt.get_fignums()]

>>> get_all_figures()

[<Figure size 640x480 with 1 Axes>,
 <Figure size 640x480 with 1 Axes>]

នៅពេលអ្នកបើកឯកសារមួយចំនួន បន្ទាប់មកដើម្បីជៀសវាងកំហុសនៃអង្គចងចាំ អ្នកត្រូវបិទពួកវា។ plt.close() បិទតួលេខបច្ចុប្បន្ន plt.close('all') បិទទាំងអស់ ហើយ plt.close(num) បិទលេខតួរលេខ។

>>> plt.close('all')
>>> get_all_figures()
[]

imshow() និង matshow():

វិធីសាស្រ្ត imshow() និង matshow() គឺជាវិធីសាស្រ្តដែលត្រូវបានប្រើប្រាស់យ៉ាងខ្លាំង។ matshow() គឺជារុំជុំវិញ imshow()។ វា​ត្រូវ​បាន​ប្រើ​ដើម្បី​មើល​ឃើញ​អារេ​លេខ​ជា​ក្រឡា​ពណ៌។

ជាមួយ Numpy ចូរយើងបង្កើតក្រឡាចត្រង្គច្បាស់លាស់ពីរ។

array1=np.diag(np.arange(2,12))[::-1]
array1[np.diag_indices_from(array1[::-1])] = np.arange(2, 12)
array2 = np.arange(array1.size).reshape(array1.shape)

ឥឡូវ​នេះ យើង​អាច​តំណាង​អារេ​១ និង​អារេ​២ ក្នុង​ទម្រង់​រូបភាព។ ដោយប្រើការយល់វចនានុក្រម យើងនឹងបិទសញ្ញាធីក និងស្លាកអ័ក្សទាំងអស់ ហើយបញ្ជូនលទ្ធផលទៅវិធីសាស្ត្រ tick_params()។

sides=('top','bottom','left','right')
nolabels={s: False for s in sides}
nolabels.update({'label%s' %s:False for s in sides})
>>> nolabels
{'top': False, 'bottom': False, 'left': False, 'right': False, 'labeltop': False, 'labelbottom': False, 
'labelleft': False, 'labelright': False}

ឥឡូវនេះយើងនឹងបិទក្រឡាចត្រង្គដោយប្រើ អ្នកគ្រប់គ្រងបរិបទ ហើយនៅលើអ័ក្សនីមួយៗ យើងនឹងហៅ matshow()។ ជាចុងក្រោយ យើងនឹងដាក់ Colorbar ដែលជាអ័ក្សថ្មីនៅក្នុងរូបភាព។

from mpl_toolkits.axes_grid1.axes_divider import make_axes_locatable

with plt.rc_context(rc={'axes.grid': False}):
    figure, (axes1, axes2) = plt.subplots(1, 2, figsize=(8, 4))
    axes1.matshow(array1)
    image=axes2.matshow(array2,cmap='RdYlGn_r')
    for axes in (axes1,axes2):
        axes.tick_params(axis='both',which='both',**nolabels)
    for i,j in zip(*array1.nonzero()):
        axes1.text(j,i,array1[i,j],color='white',ha='center',va='center')

    divider=make_axes_locatable(axes2)
    cax=divider.append_axes("right",size='5%',pad=0)
    plt.colorbar(image,cax=cax,ax=[axes1,axes2])
    figure.suptitle('Heatmaps with "Axes matshow"',fontsize=16)

    plt.show()

ពិន

គ្រោងជាមួយខ្លាឃ្មុំផេនដា៖

ខ្លាឃ្មុំផេនដាបានមកជាមួយវិធីសាស្រ្តរៀបចំផែនការរបស់វា។ វិធីសាស្រ្តរៀបចំផែនការរបស់ផេនដាគឺរុំជុំវិញការហៅ matplotlib ដែលមានស្រាប់។

ឧទាហរណ៍ វិធីសាស្ត្រ plot() ដែលយើងប្រើ Pandas នៅលើ Series និង DataFrame គឺគ្រាន់តែជាការរុំជុំវិញ plt.plot() ប៉ុណ្ណោះ។ ដូចដែលយើងដឹងរួចមកហើយថា plt.plot() សំដៅលើតួរលេខបច្ចុប្បន្ន និងអ័ក្ស Pandas ធ្វើតាមដូចគ្នា។ ឧទាហរណ៍មួយទៀតគឺប្រសិនបើសន្ទស្សន៍នៃ Pandas Dataframe មានកាលបរិច្ឆេទនោះ Pandas ហៅ gcf().autofmt_xdate() ដើម្បីទាញយកតួលេខបច្ចុប្បន្ន ហើយវាក៏ធ្វើទ្រង់ទ្រាយអ័ក្ស x ដោយស្វ័យប្រវត្តិផងដែរ។

ចូរយើងយល់ពីគំនិតទាំងនេះជាមួយនឹងឧទាហរណ៍កូដមួយចំនួន។ ដំបូងដំឡើង pandas ដោយប្រើ pip ។

pip install pandas
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np

series=pd.Series(np.arange(5),index=list('abcde'))
axes=series.plot()

ឥឡូវនេះយើងបានបង្កើត AxesSubplot នៅក្នុង Pandas ។ ពិនិត្យប្រភេទដើម្បីប្រាកដថាវា។

>>> type(axes)
<class 'matplotlib.axes._subplots.AxesSubplot'>
>>> id(axes)==id(plt.gca())
True

ខ្លាឃ្មុំផេនដាជាមួយ matplotlib៖

វាជាការប្រសើរជាងក្នុងការយល់ដឹងអំពីស្ថាបត្យកម្មផ្ទៃក្នុងនៅពេលលាយវិធីរៀបចំផែនការរបស់ Pandas ជាមួយនឹងការហៅ matplotlib ។ យើង​នឹង​ឃើញ​ឧទាហរណ៍​មួយ​ដែល​យើង​រៀប​ចំ​ផែន​ការ ការផ្លាស់ប្តូរមធ្យម នៃស៊េរីពេលវេលាហិរញ្ញវត្ថុដែលត្រូវបានគេមើលយ៉ាងទូលំទូលាយ។ យើងនឹងបង្កើតស៊េរី Pandas និង call plot() method នៅលើនោះ។ បន្ទាប់មកយើងនឹងប្តូរវាតាមអ័ក្សរបស់វាដែលបង្កើតឡើងដោយ plt.gca() របស់ matplotlib ។

import matplotlib.transforms as mtransforms

url = 'https://fred.stlouisfed.org/graph/fredgraph.csv?id=VIXCLS'
vix = pd.read_csv(url, index_col=0, parse_dates=True, na_values='.',infer_datetime_format=True,squeeze=True).dropna()
mean_average=vix.rolling('90d').mean()
state = pd.cut(mean_average, bins=[-np.inf, 14, 18, 24, np.inf],labels=range(4))
cmap = plt.get_cmap('RdYlGn_r')
mean_average.plot(color='black', linewidth=1.5, marker='', figsize=(8, 4),label='VIX 90d MA')
axes = plt.gca()
axes.set_xlabel('')
axes.set_ylabel('90d moving average: CBOE VIX')
axes.set_title('Volatility Regime State')
axes.grid(False)
axes.legend(loc='upper center')
axes.set_xlim(xmin=mean_average.index[0], xmax=mean_average.index[-1])
trans = mtransforms.blended_transform_factory(axes.transData, axes.transAxes)
for i, color in enumerate(cmap([0.2, 0.4, 0.6, 0.8])):
    axes.fill_between(mean_average.index, 0, 1, where=state==i,facecolor=color, transform=trans)
axes.axhline(vix.mean(), linestyle='dashed', color='xkcd:dark grey',alpha=0.6, label='Full-period mean', marker='')

plt.show()

ការពន្យល់នៃកូដ៖

  • អានសៀវភៅ ឯកសារ CSV ពី URL ដែលបានរៀបរាប់ និងបំប្លែងវាទៅជាស៊េរី Pandas ដោយរក្សាទុកទៅជា vix អថេរ។
  • មុខងារ rolling() ត្រូវបានប្រើជាចម្បងនៅក្នុងទិន្នន័យស៊េរីពេលវេលា។ យើង​អាច​ធ្វើ​ការ​គណនា​បង្អួច​វិល​ជាមួយ​នឹង​មុខងារ rolling() ។ នៅក្នុងពាក្យជាមូលដ្ឋានបំផុត យើងអនុវត្តប្រតិបត្តិការគណិតវិទ្យានៅលើបង្អួចនៃទំហំ n ក្នុងពេលតែមួយ។ ទំហំនៃបង្អួចមានន័យថាចំនួននៃការសង្កេតដែលត្រូវបានប្រើសម្រាប់ការគណនាស្ថិតិ។ ប្រសិនបើបង្អួចមានទំហំ n មានន័យថា n តម្លៃជាប់គ្នាក្នុងពេលតែមួយ។ នៅទីនេះយើងកំពុងអនុវត្តប្រតិបត្តិការមធ្យមនៅលើ vix លើបង្អួចនីមួយៗ។
  • មុខងារកាត់ត្រូវបានប្រើដើម្បីបែងចែក និងតម្រៀបទិន្នន័យទៅជាធុង។
  • យើង​កំពុង​ហៅ​មុខងារ plot() ហើយ​សំដៅ​យ៉ាង​ច្បាស់​ទៅ​អ័ក្ស​បច្ចុប្បន្ន។
  • ប្លុកទីពីរនៃកូដបង្កើតប្លុកដែលបំពេញដោយពណ៌ដែលត្រូវគ្នានឹងធុងនីមួយៗនៃ state.cmap([0.2,04,0.6,0.8]) .វាមានន័យថា “សម្រាប់ពណ៌នៅលេខ 20, 40, 60, និង 80 'percentile 'តាមវិសាលគម ColorMaps' នាំយើងនូវលំដាប់ RGBA។ ដើម្បីគូសផែនទីពណ៌ RGBA នីមួយៗត្រឡប់ទៅស្ថានភាព enumerate() ត្រូវបានប្រើ។

ពិន

ប្រធានបទបន្ថែម៖

ការកំណត់រចនាសម្ព័ន្ធ និងរចនាប័ទ្ម៖

នៅក្នុង matplotlib អ្នកអាចកំណត់រចនាសម្ព័ន្ធរចនាប័ទ្មនៅទូទាំងគ្រោងផ្សេងគ្នាតាមរបៀបឯកសណ្ឋាន។ មានវិធីពីរយ៉ាងដើម្បីធ្វើដូច្នេះ។

  • ប្ដូរតាមបំណងឯកសារ matplotlibrc ។
  • ផ្លាស់ប្តូរប៉ារ៉ាម៉ែត្រកំណត់រចនាសម្ព័ន្ធពីស្គ្រីប .py ឬអន្តរកម្ម។

ឯកសារ matplotlibrc គឺជាឯកសារអត្ថបទដែលមានការកំណត់ផ្ទាល់ខ្លួនរបស់អ្នកប្រើប្រាស់ ហើយអាចចងចាំបានរវាងវគ្គ។

យើងក៏អាចផ្លាស់ប្តូរប៉ារ៉ាម៉ែត្រកំណត់រចនាសម្ព័ន្ធអន្តរកម្មដូចដែលបានរៀបរាប់ពីមុន។ ដោយសារយើងបាននាំចូល matplotlib.pyplot ជា plt យើងអាចចូលប្រើ rcParams។

>>> [attr for attr in dir(plt) if attr.startswith('rc')]
['rc', 'rcParams', 'rcParamsDefault', 'rcParamsOrig', 'rc_context', 'rcdefaults', 'rcsetup']

វត្ថុដែលចាប់ផ្តើមដោយ 'rc' គឺជាមធ្យោបាយដើម្បីធ្វើអន្តរកម្មជាមួយការកំណត់គ្រោង និងរចនាប័ទ្ម។

plt.rcdefaults() ជំនួសប៉ារ៉ាម៉ែត្រ rc ទៅតម្លៃលំនាំដើមដែលបានរាយនៅ reParamsDefault ។ វាបដិសេធអ្វីដែលអ្នកបានប្ដូរតាមបំណង។

plt.rc() គឺសម្រាប់កំណត់ប៉ារ៉ាម៉ែត្រអន្តរកម្ម។

plt.rcParams() គឺជាវត្ថុដែលស្រដៀងនឹងវចនានុក្រម។ ការផ្លាស់ប្តូរតាមបំណងនៅក្នុងឯកសារ matplotlibrc ត្រូវបានឆ្លុះបញ្ចាំងនៅទីនេះ។ អ្នកក៏អាចផ្លាស់ប្តូរវត្ថុនេះដោយផ្ទាល់ផងដែរ។

# changing rc
plt.rc('lines', linewidth=2, color='g')

#Changing rcParams
plt.rcParams['lines.linewidth'] = 2
plt.rcParams['lines.color'] = 'r'

ដើម្បីមើលរចនាប័ទ្មដែលមាន៖

>>> plt.style.available
['Solarize_Light2', '_classic_test_patch', 'bmh', 'classic', 'dark_background', 'fast', 'fivethirtyeight', 'ggplot',
 'grayscale', 'seaborn', 'seaborn-bright', 'seaborn-colorblind', 'seaborn-dark', 'seaborn-dark-palette', 'seaborn-darkgrid',
 'seaborn-deep', 'seaborn-muted', 'seaborn-notebook', 'seaborn-paper', 'seaborn-pastel', 'seaborn-poster', 'seaborn-talk', 
 'seaborn-ticks', 'seaborn-white', 'seaborn-whitegrid', 'tableau-colorblind10']

ដើម្បីកំណត់រចនាប័ទ្ម៖

plt.style.use('fivethirtyeight')

របៀបអន្តរកម្ម៖

ដូចដែលបានរៀបរាប់រួចហើយ matplotlib ធ្វើអន្តរកម្មជាមួយ backend ផ្សេងគ្នា។ ផ្នែកខាងក្រោយធ្វើការងារសំខាន់ក្នុងការបង្ហាញគំនូសតាង។ ផ្នែកខាងក្រោយមួយចំនួនមានអន្តរកម្ម និងចង្អុលបង្ហាញអ្នកប្រើប្រាស់នៅពេលណាដែលពួកគេត្រូវបានផ្លាស់ប្តូរ។

អ្នកអាចពិនិត្យមើលស្ថានភាពរបស់វាដោយ៖

>>> plt.rcParams['interactive']
False

អ្នកក៏អាចប្តូរវាបើក/បិទបានដែរ៖

>>> plt.ion()
>>> plt.rcParams['interactive']
True
>>> plt.ioff()
>>> plt.rcParams['interactive']
False

ការប្រើប្រាស់មុខងារអន្តរកម្មនេះគឺ៖

  • យើងបានប្រើ plt.show() ដើម្បីបង្ហាញតារាង។ យើងមិនត្រូវការមុខងារនេះទេ ប្រសិនបើរបៀបអន្តរកម្មត្រូវបានបើក ហើយនឹងត្រូវបានអាប់ដេតនៅពេលយើងយោងពួកវា។
  • plt.show() ត្រូវការដើម្បីបង្ហាញតារាងប្រសិនបើរបៀបអន្តរកម្មត្រូវបានបិទ ហើយ plt.draw() ដើម្បីធ្វើបច្ចុប្បន្នភាពតារាង។

ឧទាហរណ៍ជាមួយរបៀបអន្តរកម្ម 'បើក'៖

plt.ion()
array = np.arange(-4, 5)
array1 = array ** 2
array2 = 10 / (array ** 2 + 1)
figure, axes = plt.subplots()
axes.plot(array, array1, 'rx', array, array2, 'b+', linestyle='solid')
axes.fill_between(array, array1, array2, where=array2>array1, interpolate=True,color='green', alpha=0.3)
legend = axes.legend(['array1', 'array2'], loc='upper center', shadow=True)
legend.get_frame().set_facecolor('#ffb19a')

ពិន

បទសម្ភាសន៍រចនាប្រព័ន្ធបំបែក
Translate »