-
Notifications
You must be signed in to change notification settings - Fork 60
Expand file tree
/
Copy pathhowto_faq.html
More file actions
859 lines (821 loc) · 77.2 KB
/
howto_faq.html
File metadata and controls
859 lines (821 loc) · 77.2 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>How-To — Matplotlib 2.2.0 documentation</title>
<link rel="stylesheet" href="../_static/mpl.css"
type="text/css" />
<link rel="stylesheet" href="../_static/pygments.css"
type="text/css" />
<link rel="stylesheet" href="../_static/gallery.css" type="text/css" />
<script type="text/javascript">
var DOCUMENTATION_OPTIONS = {
URL_ROOT: '../',
VERSION: '2.2.0',
COLLAPSE_INDEX: false,
FILE_SUFFIX: '.html',
HAS_SOURCE: true,
SOURCELINK_SUFFIX: '.txt'
};
</script>
<script type="text/javascript" src="../_static/jquery.js"></script>
<script type="text/javascript" src="../_static/underscore.js"></script>
<script type="text/javascript" src="../_static/doctools.js"></script>
<link rel="search" type="application/opensearchdescription+xml"
title="Search within Matplotlib 2.2.0 documentation"
href="../_static/opensearch.xml"/>
<link rel="shortcut icon" href="../_static/favicon.ico"/>
<link rel="index" title="Index" href="../genindex.html"
/>
<link rel="search" title="Search" href="../search.html"
/>
<link rel="top" title="Matplotlib 2.2.0 documentation" href="../index.html" />
<link rel="up" title="The Matplotlib FAQ" href="index.html" />
<link rel="next" title="Troubleshooting" href="troubleshooting_faq.html" />
<link rel="prev" title="Installation" href="installing_faq.html" />
<link rel="canonical" href="https://matplotlib.org/stable/faq/howto_faq.html" />
</head>
<body>
<div id="unreleased-message"> You are reading an old version of the documentation (v2.2.0). For the latest version see <a href="https://matplotlib.org/stable/faq/howto_faq.html">https://matplotlib.org/stable/faq/howto_faq.html</a></div>
<div style="background-color: white; text-align: left; padding: 10px 10px 15px 15px; position: relative;">
<a href="../index.html">
<div style="float: left; position: absolute; width: 496px; bottom: 0; padding-bottom: 24px"><span style="float: right; color: #789; background: white">Version 2.2.0</span></div>
<img src="../_static/logo2.png" height="125px" border="0" alt="matplotlib"/></a>
<!-- The "Fork me on github" ribbon -->
<div id="forkongithub"><a href="https://github.com/matplotlib/matplotlib">Fork me on GitHub</a></div>
</div>
<div class="related">
<h3>Navigation</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="../genindex.html" title="General Index"
accesskey="I">index</a></li>
<li class="right" >
<a href="../py-modindex.html" title="Python Module Index"
>modules</a> |</li>
<li class="right" >
<a href="troubleshooting_faq.html" title="Troubleshooting"
accesskey="N">next</a> |</li>
<li class="right" >
<a href="installing_faq.html" title="Installation"
accesskey="P">previous</a> |</li>
<li><a href="../index.html">home</a>| </li>
<li><a href="../gallery/index.html">examples</a>| </li>
<li><a href="../tutorials/index.html">tutorials</a>| </li>
<li><a href="../api/pyplot_summary.html">pyplot</a>| </li>
<li><a href="../contents.html">docs</a> »</li>
<li><a href="index.html" accesskey="U">The Matplotlib FAQ</a> »</li>
</ul>
</div>
<div class="sphinxsidebar">
<div class="sphinxsidebarwrapper">
<h3><a href="../contents.html">Table Of Contents</a></h3>
<ul>
<li><a class="reference internal" href="#">How-To</a><ul>
<li><a class="reference internal" href="#plotting-howto">Plotting: howto</a><ul>
<li><a class="reference internal" href="#plot-numpy-datetime64-values">Plot <code class="docutils literal notranslate"><span class="pre">numpy.datetime64</span></code> values</a></li>
<li><a class="reference internal" href="#find-all-objects-in-a-figure-of-a-certain-type">Find all objects in a figure of a certain type</a></li>
<li><a class="reference internal" href="#how-to-prevent-ticklabels-from-having-an-offset">How to prevent ticklabels from having an offset</a></li>
<li><a class="reference internal" href="#save-transparent-figures">Save transparent figures</a></li>
<li><a class="reference internal" href="#save-multiple-plots-to-one-pdf-file">Save multiple plots to one pdf file</a></li>
<li><a class="reference internal" href="#move-the-edge-of-an-axes-to-make-room-for-tick-labels">Move the edge of an axes to make room for tick labels</a></li>
<li><a class="reference internal" href="#automatically-make-room-for-tick-labels">Automatically make room for tick labels</a></li>
<li><a class="reference internal" href="#configure-the-tick-widths">Configure the tick widths</a></li>
<li><a class="reference internal" href="#align-my-ylabels-across-multiple-subplots">Align my ylabels across multiple subplots</a></li>
<li><a class="reference internal" href="#skip-dates-where-there-is-no-data">Skip dates where there is no data</a></li>
<li><a class="reference internal" href="#control-the-depth-of-plot-elements">Control the depth of plot elements</a></li>
<li><a class="reference internal" href="#make-the-aspect-ratio-for-plots-equal">Make the aspect ratio for plots equal</a></li>
<li><a class="reference internal" href="#multiple-y-axis-scales">Multiple y-axis scales</a></li>
<li><a class="reference internal" href="#generate-images-without-having-a-window-appear">Generate images without having a window appear</a></li>
<li><a class="reference internal" href="#use-show">Use <code class="docutils literal notranslate"><span class="pre">show()</span></code></a></li>
<li><a class="reference internal" href="#interpreting-box-plots-and-violin-plots">Interpreting box plots and violin plots</a></li>
</ul>
</li>
<li><a class="reference internal" href="#contributing-howto">Contributing: howto</a><ul>
<li><a class="reference internal" href="#request-a-new-feature">Request a new feature</a></li>
<li><a class="reference internal" href="#reporting-a-bug-or-submitting-a-patch">Reporting a bug or submitting a patch</a></li>
<li><a class="reference internal" href="#contribute-to-matplotlib-documentation">Contribute to Matplotlib documentation</a></li>
</ul>
</li>
<li><a class="reference internal" href="#matplotlib-in-a-web-application-server">Matplotlib in a web application server</a><ul>
<li><a class="reference internal" href="#matplotlib-with-apache">Matplotlib with apache</a></li>
<li><a class="reference internal" href="#matplotlib-with-django">Matplotlib with django</a></li>
<li><a class="reference internal" href="#matplotlib-with-zope">Matplotlib with zope</a></li>
<li><a class="reference internal" href="#clickable-images-for-html">Clickable images for HTML</a></li>
</ul>
</li>
<li><a class="reference internal" href="#search-examples">Search examples</a></li>
<li><a class="reference internal" href="#cite-matplotlib">Cite Matplotlib</a></li>
</ul>
</li>
</ul>
<div class="relations">
<h3>Related Topics</h3>
<ul>
<li><a href="../contents.html">Documentation overview</a><ul>
<li><a href="index.html">The Matplotlib FAQ</a><ul>
<li>Previous: <a href="installing_faq.html" title="previous chapter">Installation</a></li>
<li>Next: <a href="troubleshooting_faq.html" title="next chapter">Troubleshooting</a></li>
</ul></li>
</ul></li>
</ul>
</div>
<div role="note" aria-label="source link">
<h3>This Page</h3>
<ul class="this-page-menu">
<li><a href="../_sources/faq/howto_faq.rst.txt"
rel="nofollow">Show Source</a></li>
</ul>
</div>
<div id="searchbox" style="display: none" role="search">
<h3>Quick search</h3>
<div class="searchformwrapper">
<form class="search" action="../search.html" method="get">
<input type="text" name="q" />
<input type="submit" value="Go" />
<input type="hidden" name="check_keywords" value="yes" />
<input type="hidden" name="area" value="default" />
</form>
</div>
</div>
<script type="text/javascript">$('#searchbox').show(0);</script>
</div>
</div>
<div class="document">
<div class="documentwrapper">
<div class="bodywrapper">
<div class="body">
<div class="section" id="how-to">
<span id="howto-faq"></span><h1>How-To<a class="headerlink" href="#how-to" title="Permalink to this headline">¶</a></h1>
<div class="contents topic" id="contents">
<p class="topic-title first">Contents</p>
<ul class="simple">
<li><a class="reference internal" href="#how-to" id="id4">How-To</a><ul>
<li><a class="reference internal" href="#plotting-howto" id="id5">Plotting: howto</a><ul>
<li><a class="reference internal" href="#plot-numpy-datetime64-values" id="id6">Plot <code class="xref py py-obj docutils literal notranslate"><span class="pre">numpy.datetime64</span></code> values</a></li>
<li><a class="reference internal" href="#find-all-objects-in-a-figure-of-a-certain-type" id="id7">Find all objects in a figure of a certain type</a></li>
<li><a class="reference internal" href="#how-to-prevent-ticklabels-from-having-an-offset" id="id8">How to prevent ticklabels from having an offset</a></li>
<li><a class="reference internal" href="#save-transparent-figures" id="id9">Save transparent figures</a></li>
<li><a class="reference internal" href="#save-multiple-plots-to-one-pdf-file" id="id10">Save multiple plots to one pdf file</a></li>
<li><a class="reference internal" href="#move-the-edge-of-an-axes-to-make-room-for-tick-labels" id="id11">Move the edge of an axes to make room for tick labels</a></li>
<li><a class="reference internal" href="#automatically-make-room-for-tick-labels" id="id12">Automatically make room for tick labels</a></li>
<li><a class="reference internal" href="#configure-the-tick-widths" id="id13">Configure the tick widths</a></li>
<li><a class="reference internal" href="#align-my-ylabels-across-multiple-subplots" id="id14">Align my ylabels across multiple subplots</a></li>
<li><a class="reference internal" href="#skip-dates-where-there-is-no-data" id="id15">Skip dates where there is no data</a></li>
<li><a class="reference internal" href="#control-the-depth-of-plot-elements" id="id16">Control the depth of plot elements</a></li>
<li><a class="reference internal" href="#make-the-aspect-ratio-for-plots-equal" id="id17">Make the aspect ratio for plots equal</a></li>
<li><a class="reference internal" href="#multiple-y-axis-scales" id="id18">Multiple y-axis scales</a></li>
<li><a class="reference internal" href="#generate-images-without-having-a-window-appear" id="id19">Generate images without having a window appear</a></li>
<li><a class="reference internal" href="#use-show" id="id20">Use <a class="reference internal" href="../api/_as_gen/matplotlib.pyplot.show.html#matplotlib.pyplot.show" title="matplotlib.pyplot.show"><code class="xref py py-func docutils literal notranslate"><span class="pre">show()</span></code></a></a></li>
<li><a class="reference internal" href="#interpreting-box-plots-and-violin-plots" id="id21">Interpreting box plots and violin plots</a></li>
</ul>
</li>
<li><a class="reference internal" href="#contributing-howto" id="id22">Contributing: howto</a><ul>
<li><a class="reference internal" href="#request-a-new-feature" id="id23">Request a new feature</a></li>
<li><a class="reference internal" href="#reporting-a-bug-or-submitting-a-patch" id="id24">Reporting a bug or submitting a patch</a></li>
<li><a class="reference internal" href="#contribute-to-matplotlib-documentation" id="id25">Contribute to Matplotlib documentation</a></li>
</ul>
</li>
<li><a class="reference internal" href="#matplotlib-in-a-web-application-server" id="id26">Matplotlib in a web application server</a><ul>
<li><a class="reference internal" href="#matplotlib-with-apache" id="id27">Matplotlib with apache</a></li>
<li><a class="reference internal" href="#matplotlib-with-django" id="id28">Matplotlib with django</a></li>
<li><a class="reference internal" href="#matplotlib-with-zope" id="id29">Matplotlib with zope</a></li>
<li><a class="reference internal" href="#clickable-images-for-html" id="id30">Clickable images for HTML</a></li>
</ul>
</li>
<li><a class="reference internal" href="#search-examples" id="id31">Search examples</a></li>
<li><a class="reference internal" href="#cite-matplotlib" id="id32">Cite Matplotlib</a></li>
</ul>
</li>
</ul>
</div>
<div class="section" id="plotting-howto">
<span id="howto-plotting"></span><h2>Plotting: howto<a class="headerlink" href="#plotting-howto" title="Permalink to this headline">¶</a></h2>
<div class="section" id="plot-numpy-datetime64-values">
<span id="howto-datetime64"></span><h3>Plot <code class="xref py py-obj docutils literal notranslate"><span class="pre">numpy.datetime64</span></code> values<a class="headerlink" href="#plot-numpy-datetime64-values" title="Permalink to this headline">¶</a></h3>
<p>As of Matplotlib 2.2, <code class="xref py py-obj docutils literal notranslate"><span class="pre">numpy.datetime64</span></code> objects are handled the same way
as <a class="reference external" href="https://docs.python.org/3/library/datetime.html#datetime.datetime" title="(in Python v3.6)"><code class="xref py py-obj docutils literal notranslate"><span class="pre">datetime.datetime</span></code></a> objects.</p>
<p>If you prefer the pandas converters and locators, you can register their
converter with the <code class="xref py py-obj docutils literal notranslate"><span class="pre">matplolib.units</span></code> module:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="kn">from</span> <span class="nn">pandas.tseries</span> <span class="k">import</span> <span class="n">converter</span> <span class="k">as</span> <span class="n">pdtc</span>
<span class="n">pdtc</span><span class="o">.</span><span class="n">register</span><span class="p">()</span>
</pre></div>
</div>
<p>If you only want to use the <a class="reference external" href="https://pandas.pydata.org/pandas-docs/stable/index.html#module-pandas" title="(in pandas v0.22.0)"><code class="xref py py-obj docutils literal notranslate"><span class="pre">pandas</span></code></a> converter for <code class="xref py py-obj docutils literal notranslate"><span class="pre">datetime64</span></code> values</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="kn">from</span> <span class="nn">pandas.tseries</span> <span class="k">import</span> <span class="n">converter</span> <span class="k">as</span> <span class="n">pdtc</span>
<span class="kn">import</span> <span class="nn">matplotlib.units</span> <span class="k">as</span> <span class="nn">munits</span>
<span class="kn">import</span> <span class="nn">numpy</span> <span class="k">as</span> <span class="nn">np</span>
<span class="n">munits</span><span class="o">.</span><span class="n">registry</span><span class="p">[</span><span class="n">np</span><span class="o">.</span><span class="n">datetime64</span><span class="p">]</span> <span class="o">=</span> <span class="n">pdtc</span><span class="o">.</span><span class="n">DatetimeConverter</span><span class="p">()</span>
</pre></div>
</div>
</div>
<div class="section" id="find-all-objects-in-a-figure-of-a-certain-type">
<span id="howto-findobj"></span><h3>Find all objects in a figure of a certain type<a class="headerlink" href="#find-all-objects-in-a-figure-of-a-certain-type" title="Permalink to this headline">¶</a></h3>
<p>Every Matplotlib artist (see <a class="reference internal" href="../tutorials/intermediate/artists.html#sphx-glr-tutorials-intermediate-artists-py"><span class="std std-ref">Artist tutorial</span></a>) has a method
called <a class="reference internal" href="../api/_as_gen/matplotlib.artist.Artist.findobj.html#matplotlib.artist.Artist.findobj" title="matplotlib.artist.Artist.findobj"><code class="xref py py-meth docutils literal notranslate"><span class="pre">findobj()</span></code></a> that can be used to
recursively search the artist for any artists it may contain that meet
some criteria (e.g., match all <a class="reference internal" href="../api/_as_gen/matplotlib.lines.Line2D.html#matplotlib.lines.Line2D" title="matplotlib.lines.Line2D"><code class="xref py py-class docutils literal notranslate"><span class="pre">Line2D</span></code></a>
instances or match some arbitrary filter function). For example, the
following snippet finds every object in the figure which has a
<code class="xref py py-obj docutils literal notranslate"><span class="pre">set_color</span></code> property and makes the object blue:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">myfunc</span><span class="p">(</span><span class="n">x</span><span class="p">):</span>
<span class="k">return</span> <span class="nb">hasattr</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="s1">'set_color'</span><span class="p">)</span>
<span class="k">for</span> <span class="n">o</span> <span class="ow">in</span> <span class="n">fig</span><span class="o">.</span><span class="n">findobj</span><span class="p">(</span><span class="n">myfunc</span><span class="p">):</span>
<span class="n">o</span><span class="o">.</span><span class="n">set_color</span><span class="p">(</span><span class="s1">'blue'</span><span class="p">)</span>
</pre></div>
</div>
<p>You can also filter on class instances:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="kn">import</span> <span class="nn">matplotlib.text</span> <span class="k">as</span> <span class="nn">text</span>
<span class="k">for</span> <span class="n">o</span> <span class="ow">in</span> <span class="n">fig</span><span class="o">.</span><span class="n">findobj</span><span class="p">(</span><span class="n">text</span><span class="o">.</span><span class="n">Text</span><span class="p">):</span>
<span class="n">o</span><span class="o">.</span><span class="n">set_fontstyle</span><span class="p">(</span><span class="s1">'italic'</span><span class="p">)</span>
</pre></div>
</div>
</div>
<div class="section" id="how-to-prevent-ticklabels-from-having-an-offset">
<span id="howto-supress-offset"></span><h3>How to prevent ticklabels from having an offset<a class="headerlink" href="#how-to-prevent-ticklabels-from-having-an-offset" title="Permalink to this headline">¶</a></h3>
<p>The default formatter will use an offset to reduce
the length of the ticklabels. To turn this feature
off on a per-axis basis:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">ax</span><span class="o">.</span><span class="n">get_xaxis</span><span class="p">()</span><span class="o">.</span><span class="n">get_major_formatter</span><span class="p">()</span><span class="o">.</span><span class="n">set_useOffset</span><span class="p">(</span><span class="kc">False</span><span class="p">)</span>
</pre></div>
</div>
<p>set the rcParam <code class="docutils literal notranslate"><span class="pre">axes.formatter.useoffset</span></code>, or use a different
formatter. See <a class="reference internal" href="../api/ticker_api.html#module-matplotlib.ticker" title="matplotlib.ticker"><code class="xref py py-mod docutils literal notranslate"><span class="pre">ticker</span></code></a> for details.</p>
</div>
<div class="section" id="save-transparent-figures">
<span id="howto-transparent"></span><h3>Save transparent figures<a class="headerlink" href="#save-transparent-figures" title="Permalink to this headline">¶</a></h3>
<p>The <a class="reference internal" href="../api/_as_gen/matplotlib.pyplot.savefig.html#matplotlib.pyplot.savefig" title="matplotlib.pyplot.savefig"><code class="xref py py-meth docutils literal notranslate"><span class="pre">savefig()</span></code></a> command has a keyword argument
<em>transparent</em> which, if ‘True’, will make the figure and axes
backgrounds transparent when saving, but will not affect the displayed
image on the screen.</p>
<p>If you need finer grained control, e.g., you do not want full transparency
or you want to affect the screen displayed version as well, you can set
the alpha properties directly. The figure has a
<a class="reference internal" href="../api/_as_gen/matplotlib.patches.Rectangle.html#matplotlib.patches.Rectangle" title="matplotlib.patches.Rectangle"><code class="xref py py-class docutils literal notranslate"><span class="pre">Rectangle</span></code></a> instance called <em>patch</em>
and the axes has a Rectangle instance called <em>patch</em>. You can set
any property on them directly (<em>facecolor</em>, <em>edgecolor</em>, <em>linewidth</em>,
<em>linestyle</em>, <em>alpha</em>). e.g.:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">fig</span> <span class="o">=</span> <span class="n">plt</span><span class="o">.</span><span class="n">figure</span><span class="p">()</span>
<span class="n">fig</span><span class="o">.</span><span class="n">patch</span><span class="o">.</span><span class="n">set_alpha</span><span class="p">(</span><span class="mf">0.5</span><span class="p">)</span>
<span class="n">ax</span> <span class="o">=</span> <span class="n">fig</span><span class="o">.</span><span class="n">add_subplot</span><span class="p">(</span><span class="mi">111</span><span class="p">)</span>
<span class="n">ax</span><span class="o">.</span><span class="n">patch</span><span class="o">.</span><span class="n">set_alpha</span><span class="p">(</span><span class="mf">0.5</span><span class="p">)</span>
</pre></div>
</div>
<p>If you need <em>all</em> the figure elements to be transparent, there is
currently no global alpha setting, but you can set the alpha channel
on individual elements, e.g.:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">ax</span><span class="o">.</span><span class="n">plot</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">,</span> <span class="n">alpha</span><span class="o">=</span><span class="mf">0.5</span><span class="p">)</span>
<span class="n">ax</span><span class="o">.</span><span class="n">set_xlabel</span><span class="p">(</span><span class="s1">'volts'</span><span class="p">,</span> <span class="n">alpha</span><span class="o">=</span><span class="mf">0.5</span><span class="p">)</span>
</pre></div>
</div>
</div>
<div class="section" id="save-multiple-plots-to-one-pdf-file">
<span id="howto-multipage"></span><h3>Save multiple plots to one pdf file<a class="headerlink" href="#save-multiple-plots-to-one-pdf-file" title="Permalink to this headline">¶</a></h3>
<p>Many image file formats can only have one image per file, but some
formats support multi-page files. Currently only the pdf backend has
support for this. To make a multi-page pdf file, first initialize the
file:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="kn">from</span> <span class="nn">matplotlib.backends.backend_pdf</span> <span class="k">import</span> <span class="n">PdfPages</span>
<span class="n">pp</span> <span class="o">=</span> <span class="n">PdfPages</span><span class="p">(</span><span class="s1">'multipage.pdf'</span><span class="p">)</span>
</pre></div>
</div>
<p>You can give the <a class="reference internal" href="../api/backend_pdf_api.html#matplotlib.backends.backend_pdf.PdfPages" title="matplotlib.backends.backend_pdf.PdfPages"><code class="xref py py-class docutils literal notranslate"><span class="pre">PdfPages</span></code></a>
object to <a class="reference internal" href="../api/_as_gen/matplotlib.pyplot.savefig.html#matplotlib.pyplot.savefig" title="matplotlib.pyplot.savefig"><code class="xref py py-func docutils literal notranslate"><span class="pre">savefig()</span></code></a>, but you have to specify
the format:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">plt</span><span class="o">.</span><span class="n">savefig</span><span class="p">(</span><span class="n">pp</span><span class="p">,</span> <span class="nb">format</span><span class="o">=</span><span class="s1">'pdf'</span><span class="p">)</span>
</pre></div>
</div>
<p>An easier way is to call
<a class="reference internal" href="../api/backend_pdf_api.html#matplotlib.backends.backend_pdf.PdfPages.savefig" title="matplotlib.backends.backend_pdf.PdfPages.savefig"><code class="xref py py-meth docutils literal notranslate"><span class="pre">PdfPages.savefig</span></code></a>:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">pp</span><span class="o">.</span><span class="n">savefig</span><span class="p">()</span>
</pre></div>
</div>
<p>Finally, the multipage pdf object has to be closed:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">pp</span><span class="o">.</span><span class="n">close</span><span class="p">()</span>
</pre></div>
</div>
</div>
<div class="section" id="move-the-edge-of-an-axes-to-make-room-for-tick-labels">
<span id="howto-subplots-adjust"></span><h3>Move the edge of an axes to make room for tick labels<a class="headerlink" href="#move-the-edge-of-an-axes-to-make-room-for-tick-labels" title="Permalink to this headline">¶</a></h3>
<p>For subplots, you can control the default spacing on the left, right,
bottom, and top as well as the horizontal and vertical spacing between
multiple rows and columns using the
<a class="reference internal" href="../api/_as_gen/matplotlib.figure.Figure.html#matplotlib.figure.Figure.subplots_adjust" title="matplotlib.figure.Figure.subplots_adjust"><code class="xref py py-meth docutils literal notranslate"><span class="pre">matplotlib.figure.Figure.subplots_adjust()</span></code></a> method (in pyplot it
is <a class="reference internal" href="../api/_as_gen/matplotlib.pyplot.subplots_adjust.html#matplotlib.pyplot.subplots_adjust" title="matplotlib.pyplot.subplots_adjust"><code class="xref py py-func docutils literal notranslate"><span class="pre">subplots_adjust()</span></code></a>). For example, to move
the bottom of the subplots up to make room for some rotated x tick
labels:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">fig</span> <span class="o">=</span> <span class="n">plt</span><span class="o">.</span><span class="n">figure</span><span class="p">()</span>
<span class="n">fig</span><span class="o">.</span><span class="n">subplots_adjust</span><span class="p">(</span><span class="n">bottom</span><span class="o">=</span><span class="mf">0.2</span><span class="p">)</span>
<span class="n">ax</span> <span class="o">=</span> <span class="n">fig</span><span class="o">.</span><span class="n">add_subplot</span><span class="p">(</span><span class="mi">111</span><span class="p">)</span>
</pre></div>
</div>
<p>You can control the defaults for these parameters in your
<code class="file docutils literal notranslate"><span class="pre">matplotlibrc</span></code> file; see <a class="reference internal" href="../tutorials/introductory/customizing.html#sphx-glr-tutorials-introductory-customizing-py"><span class="std std-ref">Customizing matplotlib</span></a>. For
example, to make the above setting permanent, you would set:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">figure</span><span class="o">.</span><span class="n">subplot</span><span class="o">.</span><span class="n">bottom</span> <span class="p">:</span> <span class="mf">0.2</span> <span class="c1"># the bottom of the subplots of the figure</span>
</pre></div>
</div>
<p>The other parameters you can configure are, with their defaults</p>
<dl class="docutils">
<dt><em>left</em> = 0.125</dt>
<dd>the left side of the subplots of the figure</dd>
<dt><em>right</em> = 0.9</dt>
<dd>the right side of the subplots of the figure</dd>
<dt><em>bottom</em> = 0.1</dt>
<dd>the bottom of the subplots of the figure</dd>
<dt><em>top</em> = 0.9</dt>
<dd>the top of the subplots of the figure</dd>
<dt><em>wspace</em> = 0.2</dt>
<dd>the amount of width reserved for space between subplots,
expressed as a fraction of the average axis width</dd>
<dt><em>hspace</em> = 0.2</dt>
<dd>the amount of height reserved for space between subplots,
expressed as a fraction of the average axis height</dd>
</dl>
<p>If you want additional control, you can create an
<a class="reference internal" href="../api/axes_api.html#matplotlib.axes.Axes" title="matplotlib.axes.Axes"><code class="xref py py-class docutils literal notranslate"><span class="pre">Axes</span></code></a> using the
<a class="reference internal" href="../api/_as_gen/matplotlib.pyplot.axes.html#matplotlib.pyplot.axes" title="matplotlib.pyplot.axes"><code class="xref py py-func docutils literal notranslate"><span class="pre">axes()</span></code></a> command (or equivalently the figure
<a class="reference internal" href="../api/_as_gen/matplotlib.figure.Figure.html#matplotlib.figure.Figure.add_axes" title="matplotlib.figure.Figure.add_axes"><code class="xref py py-meth docutils literal notranslate"><span class="pre">add_axes()</span></code></a> method), which allows you to
specify the location explicitly:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">ax</span> <span class="o">=</span> <span class="n">fig</span><span class="o">.</span><span class="n">add_axes</span><span class="p">([</span><span class="n">left</span><span class="p">,</span> <span class="n">bottom</span><span class="p">,</span> <span class="n">width</span><span class="p">,</span> <span class="n">height</span><span class="p">])</span>
</pre></div>
</div>
<p>where all values are in fractional (0 to 1) coordinates. See
<a class="reference internal" href="../gallery/subplots_axes_and_figures/axes_demo.html#sphx-glr-gallery-subplots-axes-and-figures-axes-demo-py"><span class="std std-ref">Axes Demo</span></a> for an example of placing axes manually.</p>
</div>
<div class="section" id="automatically-make-room-for-tick-labels">
<span id="howto-auto-adjust"></span><h3>Automatically make room for tick labels<a class="headerlink" href="#automatically-make-room-for-tick-labels" title="Permalink to this headline">¶</a></h3>
<div class="admonition note">
<p class="first admonition-title">Note</p>
<p>This is now easier to handle than ever before.
Calling <a class="reference internal" href="../api/_as_gen/matplotlib.pyplot.tight_layout.html#matplotlib.pyplot.tight_layout" title="matplotlib.pyplot.tight_layout"><code class="xref py py-func docutils literal notranslate"><span class="pre">tight_layout()</span></code></a> can fix many common
layout issues. See the <a class="reference internal" href="../tutorials/intermediate/tight_layout_guide.html#sphx-glr-tutorials-intermediate-tight-layout-guide-py"><span class="std std-ref">Tight Layout guide</span></a>.</p>
<p class="last">The information below is kept here in case it is useful for other
purposes.</p>
</div>
<p>In most use cases, it is enough to simply change the subplots adjust
parameters as described in <a class="reference internal" href="#howto-subplots-adjust"><span class="std std-ref">Move the edge of an axes to make room for tick labels</span></a>. But in some
cases, you don’t know ahead of time what your tick labels will be, or
how large they will be (data and labels outside your control may be
being fed into your graphing application), and you may need to
automatically adjust your subplot parameters based on the size of the
tick labels. Any <a class="reference internal" href="../api/text_api.html#matplotlib.text.Text" title="matplotlib.text.Text"><code class="xref py py-class docutils literal notranslate"><span class="pre">Text</span></code></a> instance can report
its extent in window coordinates (a negative x coordinate is outside
the window), but there is a rub.</p>
<p>The <a class="reference internal" href="../api/backend_bases_api.html#matplotlib.backend_bases.RendererBase" title="matplotlib.backend_bases.RendererBase"><code class="xref py py-class docutils literal notranslate"><span class="pre">RendererBase</span></code></a> instance, which is
used to calculate the text size, is not known until the figure is
drawn (<a class="reference internal" href="../api/_as_gen/matplotlib.figure.Figure.html#matplotlib.figure.Figure.draw" title="matplotlib.figure.Figure.draw"><code class="xref py py-meth docutils literal notranslate"><span class="pre">draw()</span></code></a>). After the window is
drawn and the text instance knows its renderer, you can call
<a class="reference internal" href="../api/text_api.html#matplotlib.text.Text.get_window_extent" title="matplotlib.text.Text.get_window_extent"><code class="xref py py-meth docutils literal notranslate"><span class="pre">get_window_extent()</span></code></a>. One way to solve
this chicken and egg problem is to wait until the figure is draw by
connecting
(<a class="reference internal" href="../api/backend_bases_api.html#matplotlib.backend_bases.FigureCanvasBase.mpl_connect" title="matplotlib.backend_bases.FigureCanvasBase.mpl_connect"><code class="xref py py-meth docutils literal notranslate"><span class="pre">mpl_connect()</span></code></a>) to the
“on_draw” signal (<a class="reference internal" href="../api/backend_bases_api.html#matplotlib.backend_bases.DrawEvent" title="matplotlib.backend_bases.DrawEvent"><code class="xref py py-class docutils literal notranslate"><span class="pre">DrawEvent</span></code></a>) and
get the window extent there, and then do something with it, e.g., move
the left of the canvas over; see <a class="reference internal" href="../users/event_handling.html#event-handling-tutorial"><span class="std std-ref">Event handling and picking</span></a>.</p>
<p>Here is an example that gets a bounding box in relative figure coordinates
(0..1) of each of the labels and uses it to move the left of the subplots
over so that the tick labels fit in the figure:</p>
<div class="figure align-center" id="id2">
<a class="reference external image-reference" href="../gallery/pyplots/auto_subplots_adjust.html"><img alt="../_images/sphx_glr_auto_subplots_adjust_001.png" src="../_images/sphx_glr_auto_subplots_adjust_001.png" style="width: 320.0px; height: 240.0px;" /></a>
<p class="caption"><span class="caption-text">Auto Subplots Adjust</span></p>
</div>
</div>
<div class="section" id="configure-the-tick-widths">
<span id="howto-ticks"></span><h3>Configure the tick widths<a class="headerlink" href="#configure-the-tick-widths" title="Permalink to this headline">¶</a></h3>
<p>Wherever possible, it is recommended to use the <code class="xref py py-meth docutils literal notranslate"><span class="pre">tick_params()</span></code> or
<code class="xref py py-meth docutils literal notranslate"><span class="pre">set_tick_params()</span></code> methods to modify tick properties:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="kn">import</span> <span class="nn">matplotlib.pyplot</span> <span class="k">as</span> <span class="nn">plt</span>
<span class="n">fig</span><span class="p">,</span> <span class="n">ax</span> <span class="o">=</span> <span class="n">plt</span><span class="o">.</span><span class="n">subplots</span><span class="p">()</span>
<span class="n">ax</span><span class="o">.</span><span class="n">plot</span><span class="p">(</span><span class="nb">range</span><span class="p">(</span><span class="mi">10</span><span class="p">))</span>
<span class="n">ax</span><span class="o">.</span><span class="n">tick_params</span><span class="p">(</span><span class="n">width</span><span class="o">=</span><span class="mi">10</span><span class="p">)</span>
<span class="n">plt</span><span class="o">.</span><span class="n">show</span><span class="p">()</span>
</pre></div>
</div>
<p>For more control of tick properties that are not provided by the above methods,
it is important to know that in Matplotlib, the ticks are <em>markers</em>. All
<a class="reference internal" href="../api/_as_gen/matplotlib.lines.Line2D.html#matplotlib.lines.Line2D" title="matplotlib.lines.Line2D"><code class="xref py py-class docutils literal notranslate"><span class="pre">Line2D</span></code></a> objects support a line (solid, dashed, etc)
and a marker (circle, square, tick). The tick width is controlled by the
<code class="docutils literal notranslate"><span class="pre">"markeredgewidth"</span></code> property, so the above effect can also be achieved by:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="kn">import</span> <span class="nn">matplotlib.pyplot</span> <span class="k">as</span> <span class="nn">plt</span>
<span class="n">fig</span><span class="p">,</span> <span class="n">ax</span> <span class="o">=</span> <span class="n">plt</span><span class="o">.</span><span class="n">subplots</span><span class="p">()</span>
<span class="n">ax</span><span class="o">.</span><span class="n">plot</span><span class="p">(</span><span class="nb">range</span><span class="p">(</span><span class="mi">10</span><span class="p">))</span>
<span class="k">for</span> <span class="n">line</span> <span class="ow">in</span> <span class="n">ax</span><span class="o">.</span><span class="n">get_xticklines</span><span class="p">()</span> <span class="o">+</span> <span class="n">ax</span><span class="o">.</span><span class="n">get_yticklines</span><span class="p">():</span>
<span class="n">line</span><span class="o">.</span><span class="n">set_markeredgewidth</span><span class="p">(</span><span class="mi">10</span><span class="p">)</span>
<span class="n">plt</span><span class="o">.</span><span class="n">show</span><span class="p">()</span>
</pre></div>
</div>
<p>The other properties that control the tick marker, and all markers,
are <code class="docutils literal notranslate"><span class="pre">markerfacecolor</span></code>, <code class="docutils literal notranslate"><span class="pre">markeredgecolor</span></code>, <code class="docutils literal notranslate"><span class="pre">markeredgewidth</span></code>,
<code class="docutils literal notranslate"><span class="pre">markersize</span></code>. For more information on configuring ticks, see
<a class="reference internal" href="../tutorials/intermediate/artists.html#axis-container"><span class="std std-ref">Axis containers</span></a> and <a class="reference internal" href="../tutorials/intermediate/artists.html#tick-container"><span class="std std-ref">Tick containers</span></a>.</p>
</div>
<div class="section" id="align-my-ylabels-across-multiple-subplots">
<span id="howto-align-label"></span><h3>Align my ylabels across multiple subplots<a class="headerlink" href="#align-my-ylabels-across-multiple-subplots" title="Permalink to this headline">¶</a></h3>
<p>If you have multiple subplots over one another, and the y data have
different scales, you can often get ylabels that do not align
vertically across the multiple subplots, which can be unattractive.
By default, Matplotlib positions the x location of the ylabel so that
it does not overlap any of the y ticks. You can override this default
behavior by specifying the coordinates of the label. The example
below shows the default behavior in the left subplots, and the manual
setting in the right subplots.</p>
<div class="figure align-center" id="id3">
<a class="reference external image-reference" href="../gallery/pyplots/align_ylabels.html"><img alt="../_images/sphx_glr_align_ylabels_001.png" src="../_images/sphx_glr_align_ylabels_001.png" style="width: 320.0px; height: 240.0px;" /></a>
<p class="caption"><span class="caption-text">Align Ylabels</span></p>
</div>
</div>
<div class="section" id="skip-dates-where-there-is-no-data">
<span id="date-index-plots"></span><h3>Skip dates where there is no data<a class="headerlink" href="#skip-dates-where-there-is-no-data" title="Permalink to this headline">¶</a></h3>
<p>When plotting time series, e.g., financial time series, one often wants
to leave out days on which there is no data, e.g., weekends. By passing
in dates on the x-xaxis, you get large horizontal gaps on periods when
there is not data. The solution is to pass in some proxy x-data, e.g.,
evenly sampled indices, and then use a custom formatter to format
these as dates. The example below shows how to use an ‘index formatter’
to achieve the desired plot:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="kn">import</span> <span class="nn">numpy</span> <span class="k">as</span> <span class="nn">np</span>
<span class="kn">import</span> <span class="nn">matplotlib.pyplot</span> <span class="k">as</span> <span class="nn">plt</span>
<span class="kn">import</span> <span class="nn">matplotlib.mlab</span> <span class="k">as</span> <span class="nn">mlab</span>
<span class="kn">import</span> <span class="nn">matplotlib.ticker</span> <span class="k">as</span> <span class="nn">ticker</span>
<span class="n">r</span> <span class="o">=</span> <span class="n">mlab</span><span class="o">.</span><span class="n">csv2rec</span><span class="p">(</span><span class="s1">'../data/aapl.csv'</span><span class="p">)</span>
<span class="n">r</span><span class="o">.</span><span class="n">sort</span><span class="p">()</span>
<span class="n">r</span> <span class="o">=</span> <span class="n">r</span><span class="p">[</span><span class="o">-</span><span class="mi">30</span><span class="p">:]</span> <span class="c1"># get the last 30 days</span>
<span class="n">N</span> <span class="o">=</span> <span class="nb">len</span><span class="p">(</span><span class="n">r</span><span class="p">)</span>
<span class="n">ind</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">arange</span><span class="p">(</span><span class="n">N</span><span class="p">)</span> <span class="c1"># the evenly spaced plot indices</span>
<span class="k">def</span> <span class="nf">format_date</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">pos</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
<span class="n">thisind</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">clip</span><span class="p">(</span><span class="nb">int</span><span class="p">(</span><span class="n">x</span><span class="o">+</span><span class="mf">0.5</span><span class="p">),</span> <span class="mi">0</span><span class="p">,</span> <span class="n">N</span><span class="o">-</span><span class="mi">1</span><span class="p">)</span>
<span class="k">return</span> <span class="n">r</span><span class="o">.</span><span class="n">date</span><span class="p">[</span><span class="n">thisind</span><span class="p">]</span><span class="o">.</span><span class="n">strftime</span><span class="p">(</span><span class="s1">'%Y-%m-</span><span class="si">%d</span><span class="s1">'</span><span class="p">)</span>
<span class="n">fig</span> <span class="o">=</span> <span class="n">plt</span><span class="o">.</span><span class="n">figure</span><span class="p">()</span>
<span class="n">ax</span> <span class="o">=</span> <span class="n">fig</span><span class="o">.</span><span class="n">add_subplot</span><span class="p">(</span><span class="mi">111</span><span class="p">)</span>
<span class="n">ax</span><span class="o">.</span><span class="n">plot</span><span class="p">(</span><span class="n">ind</span><span class="p">,</span> <span class="n">r</span><span class="o">.</span><span class="n">adj_close</span><span class="p">,</span> <span class="s1">'o-'</span><span class="p">)</span>
<span class="n">ax</span><span class="o">.</span><span class="n">xaxis</span><span class="o">.</span><span class="n">set_major_formatter</span><span class="p">(</span><span class="n">ticker</span><span class="o">.</span><span class="n">FuncFormatter</span><span class="p">(</span><span class="n">format_date</span><span class="p">))</span>
<span class="n">fig</span><span class="o">.</span><span class="n">autofmt_xdate</span><span class="p">()</span>
<span class="n">plt</span><span class="o">.</span><span class="n">show</span><span class="p">()</span>
</pre></div>
</div>
</div>
<div class="section" id="control-the-depth-of-plot-elements">
<span id="howto-set-zorder"></span><h3>Control the depth of plot elements<a class="headerlink" href="#control-the-depth-of-plot-elements" title="Permalink to this headline">¶</a></h3>
<p>Within an axes, the order that the various lines, markers, text,
collections, etc appear is determined by the
<a class="reference internal" href="../api/_as_gen/matplotlib.artist.Artist.set_zorder.html#matplotlib.artist.Artist.set_zorder" title="matplotlib.artist.Artist.set_zorder"><code class="xref py py-meth docutils literal notranslate"><span class="pre">set_zorder()</span></code></a> property. The default
order is patches, lines, text, with collections of lines and
collections of patches appearing at the same level as regular lines
and patches, respectively:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">line</span><span class="p">,</span> <span class="o">=</span> <span class="n">ax</span><span class="o">.</span><span class="n">plot</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">,</span> <span class="n">zorder</span><span class="o">=</span><span class="mi">10</span><span class="p">)</span>
</pre></div>
</div>
See <a class="reference internal" href="../gallery/misc/zorder_demo.html#sphx-glr-gallery-misc-zorder-demo-py"><span class="std std-ref">Zorder Demo</span></a> for a complete example.<p>You can also use the Axes property
<a class="reference internal" href="../api/_as_gen/matplotlib.axes.Axes.set_axisbelow.html#matplotlib.axes.Axes.set_axisbelow" title="matplotlib.axes.Axes.set_axisbelow"><code class="xref py py-meth docutils literal notranslate"><span class="pre">set_axisbelow()</span></code></a> to control whether the grid
lines are placed above or below your other plot elements.</p>
</div>
<div class="section" id="make-the-aspect-ratio-for-plots-equal">
<span id="howto-axis-equal"></span><h3>Make the aspect ratio for plots equal<a class="headerlink" href="#make-the-aspect-ratio-for-plots-equal" title="Permalink to this headline">¶</a></h3>
<p>The Axes property <a class="reference internal" href="../api/_as_gen/matplotlib.axes.Axes.set_aspect.html#matplotlib.axes.Axes.set_aspect" title="matplotlib.axes.Axes.set_aspect"><code class="xref py py-meth docutils literal notranslate"><span class="pre">set_aspect()</span></code></a> controls the
aspect ratio of the axes. You can set it to be ‘auto’, ‘equal’, or
some ratio which controls the ratio:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">ax</span> <span class="o">=</span> <span class="n">fig</span><span class="o">.</span><span class="n">add_subplot</span><span class="p">(</span><span class="mi">111</span><span class="p">,</span> <span class="n">aspect</span><span class="o">=</span><span class="s1">'equal'</span><span class="p">)</span>
</pre></div>
</div>
See <a class="reference internal" href="../gallery/subplots_axes_and_figures/axis_equal_demo.html#sphx-glr-gallery-subplots-axes-and-figures-axis-equal-demo-py"><span class="std std-ref">Axis Equal Demo</span></a> for a
complete example.</div>
<div class="section" id="multiple-y-axis-scales">
<span id="howto-twoscale"></span><h3>Multiple y-axis scales<a class="headerlink" href="#multiple-y-axis-scales" title="Permalink to this headline">¶</a></h3>
<p>A frequent request is to have two scales for the left and right
y-axis, which is possible using <a class="reference internal" href="../api/_as_gen/matplotlib.pyplot.twinx.html#matplotlib.pyplot.twinx" title="matplotlib.pyplot.twinx"><code class="xref py py-func docutils literal notranslate"><span class="pre">twinx()</span></code></a> (more
than two scales are not currently supported, though it is on the wish
list). This works pretty well, though there are some quirks when you
are trying to interactively pan and zoom, because both scales do not get
the signals.</p>
<p>The approach uses <a class="reference internal" href="../api/_as_gen/matplotlib.pyplot.twinx.html#matplotlib.pyplot.twinx" title="matplotlib.pyplot.twinx"><code class="xref py py-func docutils literal notranslate"><span class="pre">twinx()</span></code></a> (and its sister
<a class="reference internal" href="../api/_as_gen/matplotlib.pyplot.twiny.html#matplotlib.pyplot.twiny" title="matplotlib.pyplot.twiny"><code class="xref py py-func docutils literal notranslate"><span class="pre">twiny()</span></code></a>) to use <em>2 different axes</em>,
turning the axes rectangular frame off on the 2nd axes to keep it from
obscuring the first, and manually setting the tick locs and labels as
desired. You can use separate <code class="docutils literal notranslate"><span class="pre">matplotlib.ticker</span></code> formatters and
locators as desired because the two axes are independent.</p>
<p>(<a class="reference external" href="../faq/howto_faq-1.py">Source code</a>, <a class="reference external" href="../faq/howto_faq-1.png">png</a>, <a class="reference external" href="../faq/howto_faq-1.pdf">pdf</a>)</p>
<div class="figure">
<img alt="../_images/howto_faq-1.png" src="../_images/howto_faq-1.png" />
</div>
See <a class="reference internal" href="../gallery/api/two_scales.html#sphx-glr-gallery-api-two-scales-py"><span class="std std-ref">Plots with different scales</span></a> for a complete example</div>
<div class="section" id="generate-images-without-having-a-window-appear">
<span id="howto-batch"></span><h3>Generate images without having a window appear<a class="headerlink" href="#generate-images-without-having-a-window-appear" title="Permalink to this headline">¶</a></h3>
<p>The easiest way to do this is use a non-interactive backend (see
<a class="reference internal" href="../tutorials/introductory/usage.html#what-is-a-backend"><span class="std std-ref">What is a backend?</span></a>) such as Agg (for PNGs), PDF, SVG or PS. In
your figure-generating script, just call the
<a class="reference internal" href="../api/matplotlib_configuration_api.html#matplotlib.use" title="matplotlib.use"><code class="xref py py-func docutils literal notranslate"><span class="pre">matplotlib.use()</span></code></a> directive before importing pylab or
pyplot:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="kn">import</span> <span class="nn">matplotlib</span>
<span class="n">matplotlib</span><span class="o">.</span><span class="n">use</span><span class="p">(</span><span class="s1">'Agg'</span><span class="p">)</span>
<span class="kn">import</span> <span class="nn">matplotlib.pyplot</span> <span class="k">as</span> <span class="nn">plt</span>
<span class="n">plt</span><span class="o">.</span><span class="n">plot</span><span class="p">([</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">])</span>
<span class="n">plt</span><span class="o">.</span><span class="n">savefig</span><span class="p">(</span><span class="s1">'myfig'</span><span class="p">)</span>
</pre></div>
</div>
<div class="admonition seealso">
<p class="first admonition-title">See also</p>
<p class="last"><a class="reference internal" href="#howto-webapp"><span class="std std-ref">Matplotlib in a web application server</span></a> for information about running matplotlib inside
of a web application.</p>
</div>
</div>
<div class="section" id="use-show">
<span id="howto-show"></span><h3>Use <a class="reference internal" href="../api/_as_gen/matplotlib.pyplot.show.html#matplotlib.pyplot.show" title="matplotlib.pyplot.show"><code class="xref py py-func docutils literal notranslate"><span class="pre">show()</span></code></a><a class="headerlink" href="#use-show" title="Permalink to this headline">¶</a></h3>
<p>When you want to view your plots on your display,
the user interface backend will need to start the GUI mainloop.
This is what <a class="reference internal" href="../api/_as_gen/matplotlib.pyplot.show.html#matplotlib.pyplot.show" title="matplotlib.pyplot.show"><code class="xref py py-func docutils literal notranslate"><span class="pre">show()</span></code></a> does. It tells
Matplotlib to raise all of the figure windows created so far and start
the mainloop. Because this mainloop is blocking by default (i.e., script
execution is paused), you should only call this once per script, at the end.
Script execution is resumed after the last window is closed. Therefore, if
you are using Matplotlib to generate only images and do not want a user
interface window, you do not need to call <code class="docutils literal notranslate"><span class="pre">show</span></code> (see <a class="reference internal" href="#howto-batch"><span class="std std-ref">Generate images without having a window appear</span></a>
and <a class="reference internal" href="../tutorials/introductory/usage.html#what-is-a-backend"><span class="std std-ref">What is a backend?</span></a>).</p>
<div class="admonition note">
<p class="first admonition-title">Note</p>
<p class="last">Because closing a figure window invokes the destruction of its plotting
elements, you should call <a class="reference internal" href="../api/_as_gen/matplotlib.pyplot.savefig.html#matplotlib.pyplot.savefig" title="matplotlib.pyplot.savefig"><code class="xref py py-func docutils literal notranslate"><span class="pre">savefig()</span></code></a> <em>before</em>
calling <code class="docutils literal notranslate"><span class="pre">show</span></code> if you wish to save the figure as well as view it.</p>
</div>
<div class="versionadded">
<p><span class="versionmodified">New in version v1.0.0: </span><code class="docutils literal notranslate"><span class="pre">show</span></code> now starts the GUI mainloop only if it isn’t already running.
Therefore, multiple calls to <code class="docutils literal notranslate"><span class="pre">show</span></code> are now allowed.</p>
</div>
<p>Having <code class="docutils literal notranslate"><span class="pre">show</span></code> block further execution of the script or the python
interpreter depends on whether Matplotlib is set for interactive mode
or not. In non-interactive mode (the default setting), execution is paused
until the last figure window is closed. In interactive mode, the execution
is not paused, which allows you to create additional figures (but the script
won’t finish until the last figure window is closed).</p>
<div class="admonition note">
<p class="first admonition-title">Note</p>
<p class="last">Support for interactive/non-interactive mode depends upon the backend.
Until version 1.0.0 (and subsequent fixes for 1.0.1), the behavior of
the interactive mode was not consistent across backends.
As of v1.0.1, only the macosx backend differs from other backends
because it does not support non-interactive mode.</p>
</div>
<p>Because it is expensive to draw, you typically will not want Matplotlib
to redraw a figure many times in a script such as the following:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">plot</span><span class="p">([</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">])</span> <span class="c1"># draw here ?</span>
<span class="n">xlabel</span><span class="p">(</span><span class="s1">'time'</span><span class="p">)</span> <span class="c1"># and here ?</span>
<span class="n">ylabel</span><span class="p">(</span><span class="s1">'volts'</span><span class="p">)</span> <span class="c1"># and here ?</span>
<span class="n">title</span><span class="p">(</span><span class="s1">'a simple plot'</span><span class="p">)</span> <span class="c1"># and here ?</span>
<span class="n">show</span><span class="p">()</span>
</pre></div>
</div>
<p>However, it is <em>possible</em> to force Matplotlib to draw after every command,
which might be what you want when working interactively at the
python console (see <a class="reference internal" href="../users/shell.html#mpl-shell"><span class="std std-ref">Using matplotlib in a python shell</span></a>), but in a script you want to
defer all drawing until the call to <code class="docutils literal notranslate"><span class="pre">show</span></code>. This is especially
important for complex figures that take some time to draw.
<a class="reference internal" href="../api/_as_gen/matplotlib.pyplot.show.html#matplotlib.pyplot.show" title="matplotlib.pyplot.show"><code class="xref py py-func docutils literal notranslate"><span class="pre">show()</span></code></a> is designed to tell Matplotlib that
you’re all done issuing commands and you want to draw the figure now.</p>
<div class="admonition note">
<p class="first admonition-title">Note</p>
<p class="last"><a class="reference internal" href="../api/_as_gen/matplotlib.pyplot.show.html#matplotlib.pyplot.show" title="matplotlib.pyplot.show"><code class="xref py py-func docutils literal notranslate"><span class="pre">show()</span></code></a> should typically only be called at
most once per script and it should be the last line of your
script. At that point, the GUI takes control of the interpreter.
If you want to force a figure draw, use
<a class="reference internal" href="../api/_as_gen/matplotlib.pyplot.draw.html#matplotlib.pyplot.draw" title="matplotlib.pyplot.draw"><code class="xref py py-func docutils literal notranslate"><span class="pre">draw()</span></code></a> instead.</p>
</div>
<p>Many users are frustrated by <code class="docutils literal notranslate"><span class="pre">show</span></code> because they want it to be a
blocking call that raises the figure, pauses the script until they
close the figure, and then allow the script to continue running until
the next figure is created and the next show is made. Something like
this:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="c1"># WARNING : illustrating how NOT to use show</span>
<span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">10</span><span class="p">):</span>
<span class="c1"># make figure i</span>
<span class="n">show</span><span class="p">()</span>
</pre></div>
</div>
<p>This is not what show does and unfortunately, because doing blocking
calls across user interfaces can be tricky, is currently unsupported,
though we have made significant progress towards supporting blocking events.</p>
<div class="versionadded">
<p><span class="versionmodified">New in version v1.0.0: </span>As noted earlier, this restriction has been relaxed to allow multiple
calls to <code class="docutils literal notranslate"><span class="pre">show</span></code>. In <em>most</em> backends, you can now expect to be
able to create new figures and raise them in a subsequent call to
<code class="docutils literal notranslate"><span class="pre">show</span></code> after closing the figures from a previous call to <code class="docutils literal notranslate"><span class="pre">show</span></code>.</p>
</div>
</div>
<div class="section" id="interpreting-box-plots-and-violin-plots">
<span id="howto-boxplot-violinplot"></span><h3>Interpreting box plots and violin plots<a class="headerlink" href="#interpreting-box-plots-and-violin-plots" title="Permalink to this headline">¶</a></h3>
<p>Tukey’s <a class="reference external" href="http://matplotlib.org/examples/pylab_examples/boxplot_demo.html">box plots</a> (Robert McGill, John W. Tukey and Wayne A. Larsen: “The American Statistician” Vol. 32, No. 1, Feb., 1978, pp. 12-16) are statistical plots that provide useful information about the data distribution such as skewness. However, bar plots with error bars are still the common standard in most scientific literature, and thus, the interpretation of box plots can be challenging for the unfamiliar reader. The figure below illustrates the different visual features of a box plot.</p>
<div class="figure">
<img alt="../_images/boxplot_explanation.png" src="../_images/boxplot_explanation.png" />
</div>
<p><a class="reference external" href="http://matplotlib.org/examples/statistics/violinplot_demo.html">Violin plots</a> are closely related to box plots but add useful information such as the distribution of the sample data (density trace).
Violin plots were added in Matplotlib 1.4.</p>
</div>
</div>
<div class="section" id="contributing-howto">
<span id="howto-contribute"></span><h2>Contributing: howto<a class="headerlink" href="#contributing-howto" title="Permalink to this headline">¶</a></h2>
<div class="section" id="request-a-new-feature">
<span id="how-to-request-feature"></span><h3>Request a new feature<a class="headerlink" href="#request-a-new-feature" title="Permalink to this headline">¶</a></h3>
<p>Is there a feature you wish Matplotlib had? Then ask! The best
way to get started is to email the developer <a class="reference external" href="mailto:matplotlib-devel%40python.org">mailing
list</a> for discussion.
This is an open source project developed primarily in the
contributors free time, so there is no guarantee that your
feature will be added. The <em>best</em> way to get the feature
you need added is to contribute it your self.</p>
</div>
<div class="section" id="reporting-a-bug-or-submitting-a-patch">
<span id="how-to-submit-patch"></span><h3>Reporting a bug or submitting a patch<a class="headerlink" href="#reporting-a-bug-or-submitting-a-patch" title="Permalink to this headline">¶</a></h3>
<p>The development of Matplotlib is organized through <a class="reference external" href="https://github.com/matplotlib/matplotlib">github</a>. If you would like
to report a bug or submit a patch please use that interface.</p>
<p>To report a bug <a class="reference external" href="https://github.com/matplotlib/matplotlib/issues/new">create an issue</a> on github
(this requires having a github account). Please include a <a class="reference external" href="http://sscce.org">Short,
Self Contained, Correct (Compilable), Example</a>
demonstrating what the bug is. Including a clear, easy to test
example makes it easy for the developers to evaluate the bug. Expect
that the bug reports will be a conversation. If you do not want to
register with github, please email bug reports to the <a class="reference external" href="mailto:matplotlib-devel%40python.org">mailing list</a>.</p>
<p>The easiest way to submit patches to Matplotlib is through pull
requests on github. Please see the <a class="reference internal" href="../devel/index.html#developers-guide-index"><span class="std std-ref">The Matplotlib Developers’ Guide</span></a> for
the details.</p>
</div>
<div class="section" id="contribute-to-matplotlib-documentation">
<span id="how-to-contribute-docs"></span><h3>Contribute to Matplotlib documentation<a class="headerlink" href="#contribute-to-matplotlib-documentation" title="Permalink to this headline">¶</a></h3>
<p>Matplotlib is a big library, which is used in many ways, and the
documentation has only scratched the surface of everything it can
do. So far, the place most people have learned all these features are
through studying the examples (<a class="reference internal" href="#how-to-search-examples"><span class="std std-ref">Search examples</span></a>), which is a
recommended and great way to learn, but it would be nice to have more
official narrative documentation guiding people through all the dark
corners. This is where you come in.</p>
<p>There is a good chance you know more about Matplotlib usage in some
areas, the stuff you do every day, than many of the core developers
who wrote most of the documentation. Just pulled your hair out
compiling Matplotlib for windows? Write a FAQ or a section for the
<a class="reference internal" href="installing_faq.html#installing-faq"><span class="std std-ref">Installation</span></a> page. Are you a digital signal processing wizard?
Write a tutorial on the signal analysis plotting functions like
<a class="reference internal" href="../api/_as_gen/matplotlib.pyplot.xcorr.html#matplotlib.pyplot.xcorr" title="matplotlib.pyplot.xcorr"><code class="xref py py-func docutils literal notranslate"><span class="pre">xcorr()</span></code></a>, <a class="reference internal" href="../api/_as_gen/matplotlib.pyplot.psd.html#matplotlib.pyplot.psd" title="matplotlib.pyplot.psd"><code class="xref py py-func docutils literal notranslate"><span class="pre">psd()</span></code></a> and
<a class="reference internal" href="../api/_as_gen/matplotlib.pyplot.specgram.html#matplotlib.pyplot.specgram" title="matplotlib.pyplot.specgram"><code class="xref py py-func docutils literal notranslate"><span class="pre">specgram()</span></code></a>. Do you use Matplotlib with
<a class="reference external" href="https://www.djangoproject.com/">django</a> or other popular web
application servers? Write a FAQ or tutorial and we’ll find a place
for it in the <a class="reference internal" href="../users/index.html#users-guide-index"><span class="std std-ref">User’s Guide</span></a>. Bundle Matplotlib in a
<a class="reference external" href="http://www.py2exe.org/">py2exe</a> app? … I think you get the idea.</p>
<p>Matplotlib is documented using the <a class="reference external" href="http://www.sphinx-doc.org/index.html">sphinx</a> extensions to restructured text
<a class="reference external" href="http://docutils.sourceforge.net/rst.html">(ReST)</a>. sphinx is an
extensible python framework for documentation projects which generates
HTML and PDF, and is pretty easy to write; you can see the source for this
document or any page on this site by clicking on the <em>Show Source</em> link
at the end of the page in the sidebar.</p>
<p>The sphinx website is a good resource for learning sphinx, but we have
put together a cheat-sheet at <a class="reference internal" href="../devel/documenting_mpl.html#documenting-matplotlib"><span class="std std-ref">Writing documentation</span></a> which
shows you how to get started, and outlines the Matplotlib conventions
and extensions, e.g., for including plots directly from external code in
your documents.</p>
<p>Once your documentation contributions are working (and hopefully
tested by actually <em>building</em> the docs) you can submit them as a patch
against git. See <a class="reference internal" href="../devel/gitwash/git_install.html#install-git"><span class="std std-ref">Install git</span></a> and <a class="reference internal" href="#how-to-submit-patch"><span class="std std-ref">Reporting a bug or submitting a patch</span></a>.
Looking for something to do? Search for <a class="reference external" href="../search.html?q=todo">TODO</a>
or look at the open issues on github.</p>
</div>
</div>
<div class="section" id="matplotlib-in-a-web-application-server">
<span id="howto-webapp"></span><h2>Matplotlib in a web application server<a class="headerlink" href="#matplotlib-in-a-web-application-server" title="Permalink to this headline">¶</a></h2>
<p>Many users report initial problems trying to use maptlotlib in web
application servers, because by default Matplotlib ships configured to
work with a graphical user interface which may require an X11
connection. Since many barebones application servers do not have X11
enabled, you may get errors if you don’t configure Matplotlib for use
in these environments. Most importantly, you need to decide what
kinds of images you want to generate (PNG, PDF, SVG) and configure the
appropriate default backend. For 99% of users, this will be the Agg
backend, which uses the C++
<a class="reference external" href="http://antigrain.com">antigrain</a>
rendering engine to make nice PNGs. The Agg backend is also
configured to recognize requests to generate other output formats
(PDF, PS, EPS, SVG). The easiest way to configure Matplotlib to use
Agg is to call:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="c1"># do this before importing pylab or pyplot</span>
<span class="kn">import</span> <span class="nn">matplotlib</span>
<span class="n">matplotlib</span><span class="o">.</span><span class="n">use</span><span class="p">(</span><span class="s1">'Agg'</span><span class="p">)</span>
<span class="kn">import</span> <span class="nn">matplotlib.pyplot</span> <span class="k">as</span> <span class="nn">plt</span>
</pre></div>
</div>
<p>For more on configuring your backend, see
<a class="reference internal" href="../tutorials/introductory/usage.html#what-is-a-backend"><span class="std std-ref">What is a backend?</span></a>.</p>
<p>Alternatively, you can avoid pylab/pyplot altogether, which will give
you a little more control, by calling the API directly as shown in
<a class="reference internal" href="../gallery/api/agg_oo_sgskip.html#sphx-glr-gallery-api-agg-oo-sgskip-py"><span class="std std-ref">The object-oriented interface</span></a>.</p>
<p>You can either generate hardcopy on the filesystem by calling savefig:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="c1"># do this before importing pylab or pyplot</span>
<span class="kn">import</span> <span class="nn">matplotlib</span>
<span class="n">matplotlib</span><span class="o">.</span><span class="n">use</span><span class="p">(</span><span class="s1">'Agg'</span><span class="p">)</span>
<span class="kn">import</span> <span class="nn">matplotlib.pyplot</span> <span class="k">as</span> <span class="nn">plt</span>
<span class="n">fig</span> <span class="o">=</span> <span class="n">plt</span><span class="o">.</span><span class="n">figure</span><span class="p">()</span>
<span class="n">ax</span> <span class="o">=</span> <span class="n">fig</span><span class="o">.</span><span class="n">add_subplot</span><span class="p">(</span><span class="mi">111</span><span class="p">)</span>
<span class="n">ax</span><span class="o">.</span><span class="n">plot</span><span class="p">([</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">])</span>
<span class="n">fig</span><span class="o">.</span><span class="n">savefig</span><span class="p">(</span><span class="s1">'test.png'</span><span class="p">)</span>
</pre></div>
</div>
<p>or by saving to a file handle:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="kn">import</span> <span class="nn">sys</span>
<span class="n">fig</span><span class="o">.</span><span class="n">savefig</span><span class="p">(</span><span class="n">sys</span><span class="o">.</span><span class="n">stdout</span><span class="p">)</span>
</pre></div>
</div>
<p>Here is an example using <a class="reference external" href="https://pillow.readthedocs.io/en/latest/">Pillow</a>.
First, the figure is saved to a BytesIO object which is then fed to
Pillow for further processing:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="kn">from</span> <span class="nn">io</span> <span class="k">import</span> <span class="n">BytesIO</span>
<span class="kn">from</span> <span class="nn">PIL</span> <span class="k">import</span> <span class="n">Image</span>
<span class="n">imgdata</span> <span class="o">=</span> <span class="n">BytesIO</span><span class="p">()</span>
<span class="n">fig</span><span class="o">.</span><span class="n">savefig</span><span class="p">(</span><span class="n">imgdata</span><span class="p">,</span> <span class="nb">format</span><span class="o">=</span><span class="s1">'png'</span><span class="p">)</span>
<span class="n">imgdata</span><span class="o">.</span><span class="n">seek</span><span class="p">(</span><span class="mi">0</span><span class="p">)</span> <span class="c1"># rewind the data</span>
<span class="n">im</span> <span class="o">=</span> <span class="n">Image</span><span class="o">.</span><span class="n">open</span><span class="p">(</span><span class="n">imgdata</span><span class="p">)</span>
</pre></div>
</div>
<div class="section" id="matplotlib-with-apache">
<h3>Matplotlib with apache<a class="headerlink" href="#matplotlib-with-apache" title="Permalink to this headline">¶</a></h3>
<p>TODO; see <a class="reference internal" href="#how-to-contribute-docs"><span class="std std-ref">Contribute to Matplotlib documentation</span></a>.</p>
</div>
<div class="section" id="matplotlib-with-django">
<h3>Matplotlib with django<a class="headerlink" href="#matplotlib-with-django" title="Permalink to this headline">¶</a></h3>
<p>TODO; see <a class="reference internal" href="#how-to-contribute-docs"><span class="std std-ref">Contribute to Matplotlib documentation</span></a>.</p>
</div>
<div class="section" id="matplotlib-with-zope">
<h3>Matplotlib with zope<a class="headerlink" href="#matplotlib-with-zope" title="Permalink to this headline">¶</a></h3>
<p>TODO; see <a class="reference internal" href="#how-to-contribute-docs"><span class="std std-ref">Contribute to Matplotlib documentation</span></a>.</p>
</div>
<div class="section" id="clickable-images-for-html">
<span id="howto-click-maps"></span><h3>Clickable images for HTML<a class="headerlink" href="#clickable-images-for-html" title="Permalink to this headline">¶</a></h3>
<p>Andrew Dalke of <a class="reference external" href="http://www.dalkescientific.com">Dalke Scientific</a>
has written a nice <a class="reference external" href="http://www.dalkescientific.com/writings/diary/archive/2005/04/24/interactive_html.html">article</a>
on how to make html click maps with Matplotlib agg PNGs. We would
also like to add this functionality to SVG. If you are interested in
contributing to these efforts that would be great.</p>
</div>
</div>
<div class="section" id="search-examples">
<span id="how-to-search-examples"></span><h2>Search examples<a class="headerlink" href="#search-examples" title="Permalink to this headline">¶</a></h2>
<p>The nearly 300 code <a class="reference internal" href="../gallery/index.html#examples-index"><span class="std std-ref">Gallery</span></a> included with the Matplotlib
source distribution are full-text searchable from the <a class="reference internal" href="../search.html"><span class="std std-ref">Search Page</span></a>
page, but sometimes when you search, you get a lot of results from the
<a class="reference internal" href="../api/index.html#api-index"><span class="std std-ref">The Matplotlib API</span></a> or other documentation that you may not be interested
in if you just want to find a complete, free-standing, working piece
of example code. To facilitate example searches, we have tagged every
code example page with the keyword <code class="docutils literal notranslate"><span class="pre">codex</span></code> for <em>code example</em> which
shouldn’t appear anywhere else on this site except in the FAQ.
So if you want to search for an example that uses an
ellipse, <a class="reference internal" href="../search.html"><span class="std std-ref">Search Page</span></a> for <code class="docutils literal notranslate"><span class="pre">codex</span> <span class="pre">ellipse</span></code>.</p>
</div>
<div class="section" id="cite-matplotlib">
<span id="how-to-cite-mpl"></span><h2>Cite Matplotlib<a class="headerlink" href="#cite-matplotlib" title="Permalink to this headline">¶</a></h2>
<p>If you want to refer to Matplotlib in a publication, you can use
“Matplotlib: A 2D Graphics Environment” by J. D. Hunter In Computing
in Science & Engineering, Vol. 9, No. 3. (2007), pp. 90-95 (see <a class="reference external" href="https://doi.org/10.1109/MCSE.2007.55">this
reference page</a>):</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>@article{Hunter:2007,
Address = {10662 LOS VAQUEROS CIRCLE, PO BOX 3014, LOS ALAMITOS, CA 90720-1314 USA},
Author = {Hunter, John D.},
Date-Added = {2010-09-23 12:22:10 -0700},
Date-Modified = {2010-09-23 12:22:10 -0700},
Isi = {000245668100019},
Isi-Recid = {155389429},
Journal = {Computing In Science \& Engineering},
Month = {May-Jun},
Number = {3},
Pages = {90--95},
Publisher = {IEEE COMPUTER SOC},
Times-Cited = {21},
Title = {Matplotlib: A 2D graphics environment},
Type = {Editorial Material},
Volume = {9},
Year = {2007},
Abstract = {Matplotlib is a 2D graphics package used for Python for application
development, interactive scripting, and publication-quality image
generation across user interfaces and operating systems.},
Bdsk-Url-1 = {http://gateway.isiknowledge.com/gateway/Gateway.cgi?GWVersion=2&SrcAuth=Alerting&SrcApp=Alerting&DestApp=WOS&DestLinkType=FullRecord;KeyUT=000245668100019}}
</pre></div>
</div>
</div>
</div>
</div>
</div>
</div>
<div class="clearer"></div>
</div>
<div class="footer">
© Copyright 2002 - 2012 John Hunter, Darren Dale, Eric Firing, Michael Droettboom and the Matplotlib development team; 2012 - 2017 The Matplotlib development team.
Last updated on Mar 06, 2018.
Created using <a
href="http://sphinx-doc.org/">Sphinx</a> 1.7.1.
</div>
<script>
(function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
(i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
})(window,document,'script','//www.google-analytics.com/analytics.js','ga');
ga('create', 'UA-55954603-1', 'auto');
ga('send', 'pageview');
</script>
</body>
<footer>
</footer>
</html>