Matplotlib 第四课

First, colors can be given as strings. For very basic colors, you can even get away with just a single letter:

Other colornames that are allowed are the HTML/CSS colornames such as "burlywood" and "chartreuse". See the full list of the 147 colornames. For the British speaking and poor spellers among us (I am not implying that British speakers are poor spellers!), we allow "grey" where-ever "gray" appears in that list of colornames. All of these colornames are case-insensitive.

Colors can also be specified by supplying a HTML/CSS hex string, such as '#0000FF' for blue. Support for an optional alpha channel was added for v2.0.

A gray level can be given instead of a color by passing a string representation of a number between 0 and 1, inclusive. '0.0' is black, while '1.0' is white. '0.75' would be a light shade of gray.

import numpy as np
import matplotlib.pyplot as plt
t = np.arange(0.0, 5.0, 0.2)
# declare the colors explicitly.
plt.plot(t, t, 'r', t, t**2, 'lightgray', t, t**3, '0.0')
plt.show()

You may come upon instances where the previous ways of specifying colors do not work. This can sometimes happen in some of the deeper, stranger levels of the library. When all else fails, the universal language of colors for matplotlib is the RGB[A] tuple. This is the "Red", "Green", "Blue", and sometimes "Alpha" tuple of floats in the range of [0, 1]. One means full saturation of that channel, so a red RGBA tuple would be (1.0, 0.0, 0.0, 1.0), whereas a partly transparent green RGBA tuple would be (0.0, 1.0, 0.0, 0.75). The documentation will usually specify whether it accepts RGB or RGBA tuples. Sometimes, a list of tuples would be required for multiple colors, and you can even supply a Nx3 or Nx4 numpy array in such cases.

In functions such as plot() and scatter(), while it may appear that they can take a color specification, what they really need is a "format specification", which includes color as part of the format. Unfortunately, such specifications are string only and so RGB[A] tuples are not supported for such arguments (but you can still pass an RGB[A] tuple for a "color" argument).

Oftentimes there is a separate argument for "alpha" where-ever you can specify a color. The value for "alpha" will usually take precedence over the alpha value in the RGBA tuple. There is no easy way around this inconsistency.

you give a cycle of color, you don't care what is the 1st 2nd 3rd … color is. what you want is color your current component with the 3rd color, the ONLY job you need to do is giving color C3.

With the advent of fancier color cycles coming from the many available styles, users needed a way to reference those colors in the style without explicitly knowing what they are. So, in v2.0, the ability to reference the first 10 iterations of the color cycle was added. Whereever one could specify a color, you can supply a 2 character string of 'C#'. So, 'C0' would be the first color, 'C1' would be the second, and so on and so forth up to 'C9'.

String symbol can be used as value of para color of plot/scatter/etc.

plt.plot(x,y, '[marker][markeredgecolor]')

t = np.arange(0.0, 5.0, 0.2)
plt.plot(t, t, "*y", t, t**2, "8m", t, t**3, "sg")
plt.show()

plt.plot(x,y, '[linecolor][linestyle]')

t = np.arange(0., 5., 0.2)
plt.plot(t, t, 'r--', t, t**2, 'bs', t, t**3, 'g^')
plt.show()

plt.plot(x,y, '[linecolor][linestyle][marker]', mfc='...', mec='...')

t = np.arange(0., 5., 0.1)
a = np.exp(-t) * np.cos(2*np.pi*t)
plt.plot( t, a , 'r:D', mfc='g', mec='y')
plt.show()

To display where the currently active matplotlibrc file was loaded from, one can do the following:

import matplotlib
print(matplotlib.matplotlib_fname())

mpl.rc('lines', linewidth=2, linestyle='-.') # <- change matplotlibrc at runtime You can also change the rc settings during runtime within a python script or interactively from the python shell. All of the rc settings are stored in a dictionary-like variable called matplotlib.rcParams, which is global to the matplotlib package. rcParams can be modified directly. Newer versions of matplotlib can use rc(), for example:

import matplotlib as mpl
import matplotlib.pyplot as plt
mpl.rcdefaults()  # revert everything back to the built-in defaults settings.

fig, (ax1, ax2) = plt.subplots(1, 2)
ax1.plot([1, 2, 3, 4])

mpl.rc('lines', linewidth=2, linestyle='-.') # <- change matplotlibrc at runtime
# Equivalent older, but still valid syntax
# mpl.rcParams['lines.linewidth'] = 2
# mpl.rcParams['lines.linestyle'] = '-.'
ax2.plot([1, 2, 3, 4])
plt.show()

plt.plot(x1, y1, x2, y2, x3, y3)

it will plot (x1, y1), (x2,y2), (x3, y3) 3 line, give each line a color in color cycle.

import numpy as np
import matplotlib.pyplot as plt
t = np.arange(0.0, 5.0, 0.2)
plt.plot(t, t, t, t**2, t, t**3)
plt.show()

imshow will produce a image with size related to the shape of data array.

.   data array                                  image produced
.   | 0 | 3 | 6 |  9 | 12 |                     +-----------------+
.   | 1 | 4 | 7 | 10 | 13 |                     |                 |
.   | 2 | 5 | 8 | 11 | 14 |   ----imshow---->   |                 |
.   | 3 | 6 | 9 | 12 | 15 |                     |                 |
.   | 3 | 6 | 9 | 12 | 15 |                     |                 |
.                                               |                 |
.                                               +-----------------+
.
.
.   data array                                  image produced
.                                               +-----------------+
.   | 0 | 3 | 6 |  9 | 12 |                     |                 |
.   | 1 | 4 | 7 | 10 | 13 |    ----imshow---->  |                 |
.                                               +-----------------+

http://tiao.io/posts/numpy-mgrid-vs-meshgrid/

np.mgrid().T is always used to produce the points of 2D space, from wich we can get some 2D images; also can be used to create a catesian product( or combination ) efficiently.

1. np.meshgrid produce the points of 2D or nD image.
2. np.mgrid.T ===> np.meshgrid

3. np.ogrid ===broadcast==> np.mgrid

   .
   .             np.ogrid[0] broadcast horizontal
   .             np.ogrid[1] broadcast vertical
   .          +----------------------------------------------+
   .          |                                              |
   .          v          .T                                  |
   .      np.mgrid    -------->    np.meshgrid             np.ogrid
   .  [[0 0 0 0 0 0 0 0 0]         [[0 1 2 3]              [[0]     copy horizontal
   .   [1 1 1 1 1 1 1 1 1]          [0 1 2 3]               [1]  ---------->
   .   [2 2 2 2 2 2 2 2 2]          [0 1 2 3]               [2]
   .   [3 3 3 3 3 3 3 3 3]]         [0 1 2 3]               [3]]
   .  [[9 8 7 6 5 4 3 2 1]          [0 1 2 3]              [.[9 8 7 6 5 4 3 2 1]]
   .   [9 8 7 6 5 4 3 2 1]          [0 1 2 3]                         |
   .   [9 8 7 6 5 4 3 2 1]          [0 1 2 3]                         |
   .   [9 8 7 6 5 4 3 2 1]]         [0 1 2 3]                         | copy vertically
   .                                [0 1 2 3]]                        v
   .                               [[9 9 9 9]
   .                                [8 8 8 8]
   .                                [7 7 7 7]
   .                                [6 6 6 6]
   .                                [5 5 5 5]
   .                                [4 4 4 4]
   .                                [3 3 3 3]
   .                                [2 2 2 2]
   .                                [1 1 1 1]]
   .                                    |
   .                                    v
   .                                (x  ,  y)
   .                                 |     |
   .      from np.meshgrid[0]<-------+     +-------> from np.meshgrid[1]
   .
   

   
   .
   .                                                                 np.meshgrid
   .      ^                                                          [[|0 1 2 3]
   .      |                                                           [|0 1 2 3]
   .      |         |         |         |         |                   [|0 1 2 3]
   .    1 +---------+---------+---------+---------+--------           [|0 1 2 3]
   .      |         |         |         |         |                +--[|0 1 2 3]
   .      |         |         |         |         |                |  [|0 1 2 3]
   .    2 +---------+---------+---------+---------+--------        |  [|0 1 2 3]
   .      |         |         |         |         |                |  [|0 1 2 3]
   .      |         |         |         |         |                |  [|0 1 2 3]]
   .    3 +---------+---------+---------+---------+--------        | [[|9 9 9 9]
   .      |         |         |         |         |                |  [|8 8 8 8]
   .      |         |         |         |         |                |  [|7 7 7 7]
   .    4 +---------+---------+---------+---------+--------        |  [|6 6 6 6]
   .      |         |         |         |         |                |  [|5 5 5 5]
   .      |         |         |         |         |                |  [|4 4 4 4]
   .    5 +---------+---------+---------+---------+--------        |  [|3 3 3 3]
   .      |         |         |         |         |                |  [|2 2 2 2]
   .      |         |         |         |         |                |  [|1 1 1 1]]
   .    6 +---------+---------+---------+---------+--------        |   -\
   .      |         |         |         |         |                \-\  |
   .      |         |         |         |         |                  v  v
   .    7 +---------+---------+---------+---------+--------         (|0 |9), (1 9), (2 9), (3 9)
   .      |         |(0,7)    |(1,7)    |         |                 (|0 |8), (1 8), (2 8), (3 8)
   .      |         |         |         |         |                 (|0 |7), (1 7), (2 7), (3 7)
   .    8 +---------+---------+---------+---------+--------         (|0 |6), (1 6), (2 6), (3 6)
   .      |         |(0,8)    |(1,8)    |         |                 (|0 |5), (1 5), (2 5), (3 5)
   .      |         |         |         |         |                 (|0 |4), (1 4), (2 4), (3 4)
   .    9 +---------+---------+---------+---------+--------         (|0 |3), (1 3), (2 3), (3 3)
   .      |         |(0,9)    |(1,9)    |         |                 (|0 |2), (1 2), (2 2), (3 2)
   .      |         |         |         |         |                 (|0 |1), (1 1), (2 1), (3 1)
   .    --+---------+---------+---------+---------+-------------->
   .      |         0         1         2         3
   .
   

xs, ys = np.mgrid[:4, 9:0:-1]
print (xs)
print (ys)
xo, yo = np.ogrid[:4, 9:0:-1]
print (xo)
print (yo)

stack horizontally or vertically two n dimension array to n+1 dimension array. stack two 1*3 array will get one 2*3 or 3*2 array.

.                 combine to n+1 D array
.                 by *unit* of column
.
.                 +--------------> ~axis=1~ | | |
. combine to      || 1 | 2 | 3 |            | | |
. n+1 D array     || 4 | 5 | 6 |            | | |
. by *unit*       |
. of row          v
.             ~axis=0~   -------
.                        -------
.                        -------
.
.                         +-----------------+
.                         v                 |
.                .................   this is the element of n+1 D
.                . | 1 | 2 | 3 | .   array, by stack at ~axis = 0~
.                .................
.                  | 4 | 5 | 6 |     new array element-0 =
.                                    [1,2,3]
.                                    new array element-1 =
.                                    [4,5,6]
.                                    so new 1+1 array =
.                                    [[1 2 3]
.                                     [4 5 6]]
.
.                    +----------------------+
.                    v                      |
.                .........           this is the element of n+1 D
.                . | 1 | . 2 | 3 |   array, by stack at ~axis = 1~
.                . | 4 | . 5 | 6 |
.                .........           new array element-0 =
.                                    [1,4]
.                                    new array element-1 =
.                                    [2,5]
.                                    new array element-2 =
.                                    [3,6]
.                                    so new 1+1 array =
.                                    [[1 4]
.                                     [2 5]
.                                     [3 6]]

a = np.array([1,2,3])
b = np.array([4,5,6])
s_a_b = np.stack((a,b))
s_a_b_1 = np.stack((a,b), axis=1)
print (s_a_b)
print (s_a_b_1)

merge horizontally two n dimension array to another n dimension array.

.
.
.  a 1*3     b 1*3                      merge every row of a and b 1*(3+3)
.  [1,2,3]  [4,5,6]  ---- hstack ---->  [1,2,3,4,5,6]
.
.
.  a 3*1   b 3*1                        merge every row of a and b 3*(1+1)
.  [[1],   [[4],                        [[1 4],
.   [2],    [5],     ---- hstack ---->   [2 5],
.   [3]]    [6]]                         [3 6]]
.
.
.  a 1*3     b 1*3                      merge every column of a and b (1+1)*3
.  [1,2,3]  [4,5,6]  ---- vstack ---->  [[1,2,3],
.                                        [4,5,6]]
.
.
.  a 3*1   b 3*1                        merge every column of a and b (3+3)*1
.  [[1],   [[4],                        [[1]
.   [2],    [5],     ---- vstack ---->   [2]
.   [3]]    [6]]                         [3]
.                                        [4]
.                                        [5]
.                                        [6]]
.

a = np.array((1,2,3))
b = np.array((4,5,6))
h_a_b = np.hstack((a,b))
print (h_a_b)
ad = np.array([[1],[2],[3]])
bd = np.array([[4],[5],[6]])
h_ad_bd = np.hstack((ad,bd))
print (h_ad_bd)

a = np.array((1,2,3))
b = np.array((4,5,6))
v_a_b = np.hstack((a,b))
print (v_a_b)
ad = np.array([[1],[2],[3]])
bd = np.array([[4],[5],[6]])
v_ad_bd = np.hstack((ad,bd))
print (v_ad_bd)

numpy.dstack([[1,2,3], [4,5,6]])

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