1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

import numpy as np
import matplotlib.pyplot as plt

x = [0, 0, 5, 10, 15, 15, 10, 5]
y = [5, 10, 15, 15, 10, 5, 0, 0]

plt.fill(x, y, color = 'cornflowerblue')

plt.xlim(-1, 16)
plt.ylim(-1, 16)

plt.xticks(np.arange(0, 16, 5))
plt.yticks(np.arange(0, 16, 5))

plt.show()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

x = np.linspace(0, 2*np.pi, 500)
y = np.sin(x)

plt.fill(x, y, color = 'cornflowerblue', alpha = 0.4)

plt.plot(x, y, color = 'cornflowerblue', alpha = 0.8)
plt.plot([x[0], x[-1]], [y[0], y[-1]], color = 'cornflowerblue', alpha = 0.8)

plt.xlim(0, 2*np.pi)
plt.ylim(-1.1, 1.1)

plt.show()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

x = np.linspace(0, 2, 500)
y1 = np.sin(2*np.pi*x)
y2 = 1.1*np.sin(3*np.pi*x)

fig, ax = plt.subplots(3, 1, sharex = 'all')

# "between y2 and 0"
ax[0].fill_between(x, 0, y2, alpha = 0.5)
ax[0].set_ylim(-1.2, 1.2)

# "between y2 and 1.1"
ax[1].fill_between(x, y2, 1.1, alpha = 0.5)
ax[1].set_ylim(-1.2, 1.2)

# "between y1 and y20"
ax[2].fill_between(x, y1, y2, alpha = 0.5)
ax[2].set_ylim(-1.2, 1.2)

plt.show()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

x = np.linspace(0, 2, 500)
y1 = np.sin(2*np.pi*x)
y2 = 1.1 * np.sin(3*np.pi*x)

fig = plt.figure()
ax = fig.add_subplot(111)

# plot yq and plot y2
ax.plot(x, y1, color = 'k', lw = 1, ls = '-')
ax.plot(x, y2, color = 'k', lw = 1, ls = '-')

# 'where y1<=y2'
ax.fill_between(x, y1, y2, where = y2>=y1, interpolate = True, facecolor = 'cornflowerblue', alpha = 0.7)

# 'where y1>=y2'
ax.fill_between(x, y1, y2, where = y2<=y1, interpolate = True, facecolor = 'darkred', alpha = 0.7)

ax.set_xlim(0, 2)
ax.set_ylim(-1.2, 1.2)

ax.grid(ls = ':', lw = 1, color = 'gray', alpha = 0.5)

plt.show()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

y = np.linspace(0, 2, 500)
x1 = np.sin(2*np.pi*y)
x2 = 1.1*np.sin(3*np.pi*y)

fig = plt.figure()
ax = fig.add_subplot(111)

# plot x1 and x2
ax.plot(x1, y, color = 'k', lw = 1, ls = '-')
ax.plot(x2, y, color = 'k', lw = 1, ls = '-')

# 'where x1<=x2'
ax.fill_betweenx(y, x1, x2, where = x2>=x1, facecolor = 'cornflowerblue', alpha=0.7)

# 'where x1>=x2'
ax.fill_betweenx(y, x1, x2, where = x2<=x1, facecolor = 'darkred', alpha=0.7)

ax.set_xlim(-1.2, 1.2)
ax.set_ylim(0, 2)

ax.grid(ls = ':', lw = 1, color = 'gray', alpha = 0.5)

plt.show()

 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

fig, ax = plt.subplots(1, 2)

# sunplot(121) data
x = np.linspace(0, 2, 500)
y1 = np.sin(2*np.pi*x)
y2 = 1.2*np.sin(3*np.pi*x)

y2 = np.ma.masked_greater(y2, 1.0)

# plot y1 and y2
ax[0].plot(x, y1, color = 'k', lw = 1, ls = '-')
ax[0].plot(x, y2, color = 'k', lw = 1, ls = '-')

# 'where ya <= y2'
ax[0].fill_between(x, y1, y2, where = y2>=y1, facecolor = 'cornflowerblue', alpha = 0.7) 

# 'where y1>=y2'
ax[0].fill_between(x, y1, y2, where = y2<=y1, facecolor = 'darkred', alpha = 0.5) 

ax[0].set_xlim(0, 2)
ax[0].set_ylim(-1.2, 1.2)

ax[0].grid(ls = ':', lw = 1, color = 'gray', alpha = 0.5)

# subplot(122) data
y = np.linspace(0, 2, 500)
x1 = np.sin(2*np.pi*y)
x2 = 1.2*np.sin(3*np.pi*y)

x2 = np.ma.masked_greater(x2, 1.0)

# plot x1 and x2
ax[1].plot(x1, y, color = 'k', lw = 1, ls = '-')
ax[1].plot(x2, y, color = 'k', lw = 1, ls = '-')

# 'where x1<=x2'
ax[1].fill_betweenx(y, x1, x2, where = x2>=x1, facecolor = 'cornflowerblue', alpha = 0.7)

# 'where x1>=x2
ax[1].fill_betweenx(y, x1, x2, where = x2<=x1, facecolor = 'darkred', alpha = 0.7)

ax[1].set_xlim(-1.2, 1.2)
ax[1].set_ylim(0, 2)

ax[1].grid(ls = ':', lw = 1, color = 'gray', alpha = 0.5)

plt.show()

1
2
3
4
5
6
7

import numpy as np
# import matplotlib as mpl
import matplotlib.pyplot as plt
from matplotlib.patches import Arc, Circle, Ellipse, Rectangle, Wedge, Shadow 
# from jupyterthemes import jtplot
# jtplot.style()
# mpl.style.use('ggplot')

 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

fig, ax = plt.subplots(2, 2)

# subplot(221)
circle = Circle((2,2), radius = 2, facecolor = 'white', edgecolor = 'cornflowerblue')
ax[0, 0].add_patch(circle)

ax[0, 0].set_xlim(-1, 5)
ax[0, 0].set_ylim(-1, 5)

# subplot(222)
rectangle = ax[0, 1].patch
rectangle.set_facecolor('gold')

circle = Circle((2,2), radius = 2, facecolor = 'white', edgecolor = 'cornflowerblue')
ax[0, 1].add_patch(circle)

ax[0, 1].set_xlim(-1, 5)
ax[0, 1].set_ylim(-1, 5)
ax[0, 1].set_aspect('equal', 'box')

# subplot(223)
rectangle = ax[1,0].patch
rectangle.set_facecolor("palegreen")
circle = Circle((2, 2), radius=2, facecolor = "white", edgecolor = "cornflowerblue")
ax[1, 0].add_patch(circle)
ax[1, 0].axis("equal")

# subplot(224)
rectangle = ax[1,1].patch
rectangle.set_facecolor("lightskyblue")
circle = Circle((2, 2), radius = 2, facecolor = "white",edgecolor = "cornflowerblue")
ax[1, 1].add_patch(circle)
ax[1, 1].axis([-1,5, -1,5])
ax[1, 1].set_yticks(np.arange(-1, 6, 1))
ax[1, 1].axis("equal")
plt.subplots_adjust(left = 0.1)
plt.show()

 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

fig, ax = plt.subplots(1, 2, subplot_kw={'aspect':'equal'})

# subplot(121)
angles = np.linspace(0, 135, 4)
ellipse = [Ellipse((2, 2), 4, 2, a) for a in angles]

for elle in ellipse:
    ax[0].add_patch(elle)
    elle.set_alpha(0.4)
    elle.set_color("cornflowerblue")

ax[0].axis([-1, 5, -1, 5])

# subplot(122)
num = np.arange(0, 100, 1)
ellipse = [Ellipse(xy = np.random.rand(2)*10, width = np.random.rand(1), height = np.random.rand(1),
           angle = np.random.rand(1)*360) for i in num]

for elle in ellipse:
    ax[1].add_patch(elle)
    elle.set_alpha(float(np.random.rand(1)))
    elle.set_color(np.random.rand(3))

ax[1].axis([-1, 11, -1, 11])
plt.tight_layout()
plt.show()

 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

fig, ax = plt.subplots(subplot_kw={'aspect':'equal'})

x1 = np.arange(1, 2.6, 0.1)
y1 = x1 + 2

x2 = np.arange(2.5, 4.1, 0.1)
y2 = -x2 + 7

# set background color
rectangle = ax.patch
rectangle.set_facecolor('lightskyblue')

# house
rectangle1 = Rectangle((1, 0), 3, 3, facecolor = 'w', edgecolor = 'rosybrown')

# door
rectangle2 = Rectangle((1.5, 0), 1, 1.5, facecolor = 'w', edgecolor = 'rosybrown', hatch = '|||')

# window
rectangle3 = Rectangle((2.9, 1.7), 0.6, 0.6, edgecolor = 'rosybrown')

rectangle_list = [rectangle1, rectangle2, rectangle3]

# roof line
ax.plot([1, 2.5, 4], [3, 4.5, 3], color = 'rosybrown')

# window line
ax.plot([3.2, 3.2], [1.7, 2.3], color = 'rosybrown')
ax.plot([2.9, 3.5], [2.0, 2.0], color = 'rosybrown')

# roof filled color
ax.fill_between(x1, 3, y1, color = 'w', interpolate = True)
ax.fill_between(x2, 3, y2, color = 'w', interpolate = True)

for rect in rectangle_list:
    ax.add_patch(rect)
    
ax.axis([0, 5, 0, 6])
plt.grid(False)
plt.show()

 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

fig, ax = plt.subplots(subplot_kw = {'aspect':'equal'})

# shadow
shadow = Ellipse((2.5, 0.5), 4.2, 0.5, color = 'silver', alpha = 0.2)
''
# base
ax.plot([1, 4], [1, 1.3], color = 'k')
base = Arc((2.5, 1.1), 3, 1, angle = 10, theta1 = 0, theta2 = 180, color= 'k', alpha = 0.8)

# wheel 
left_wheel = Ellipse((1, 1), 0.7, 0.4, angle = 95, color = 'k')
right_wheel = Ellipse((4, 1.3), 0.7, 0.4, angle = 85, color = 'k')

# joinstyle
bottom_joinstyle1 = Ellipse((2.5, 2), 1, 0.3, facecolor = 'silver', edgecolor = 'w')
bottom_joinstyle2 = Ellipse((2.5, 1.7), 1, 0.3, facecolor = 'silver', edgecolor = 'w')
left_joinstyle = Ellipse((1.5, 0.75), 0.5, 0.25, angle = 90, color = 'k')
left_arm_jointstyle1 = Wedge((0.3, 4.55), 0.1, 0, 360, color = 'k')
left_arm_jointstyle2 = Wedge((0, 4.0), 0.2, 290, 250, color = 'k')
right_jointstyle = Ellipse((4, 5.75), 0.5, 0.25, angle = 90, color = 'k')
right_arm_jointstyle1 = Wedge((4.3, 6.95), 0.1, 0, 360, color = 'k')
right_arm_jointstyle2 = Wedge((4.3, 7.45), 0.2,110, 70, color = 'k')
top_jointstyle1 = Ellipse((2.5, 6.2), 0.5, 0.2, facecolor = 'silver', edgecolor = 'w')
top_jointstyle2 = Ellipse((2.5, 6.3), 0.5, 0.2, facecolor = 'silver', edgecolor = 'w')

# body
body = Rectangle((1, 2.1), 3, 4, color = 'steelblue')

# arms
left_arm1 = ax.plot([0.3, 1-0.125], [4.55, 5.75], color = "silver", lw = 4)
left_arm2 = ax.plot([0, 0.3], [4.2,4.55], color = "silver", lw = 4)
right_arm1 = ax.plot([4+0.125, 4.3], [5.75, 6.95], color = "silver", lw = 4)
right_arm2 = ax.plot([4.3, 4.3], [6.95, 7.25], color = "silver", lw = 4)

# head
ax.plot([1 ,4], [6.4, 6.4], color = "steelblue")
ax.plot([1,4],[6.4,6.4],color="steelblue")
head = Arc((2.5, 6.4), 3, 2.5, angle = 0, theta1 = 0, theta2 = 180, color = "steelblue")

# eyes
left_eye = Wedge((2, 7), 0.4, 0, 360, color = "gold")
left_eye_center = Wedge((2, 7), 0.3, 15, 345, color = "k")
right_eye = Wedge((3, 7), 0.4, 0, 360, color = "k")
right_eye_center = Wedge((3, 7), 0.3, 165, 195, color = "darkred")

polygon = [shadow, base, left_wheel, right_wheel, bottom_joinstyle1, bottom_joinstyle2, left_joinstyle,
          left_arm_jointstyle1, left_arm_jointstyle2, right_jointstyle, right_arm_jointstyle1,
          right_arm_jointstyle2, top_jointstyle1, top_jointstyle1, body, head, left_eye, left_eye_center,
          right_eye, right_eye_center]

for pln in polygon:
    ax.add_patch(pln)

ax.axis([-1, 6, 0, 10])
plt.show()

 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

fig, ax = plt.subplots(2, 2)

x = np.linspace(0, 2*np.pi, 500)
y1 = 2 * np.cos(x)
y2 = 2 * np.sin(x)

# subplot(221)
ax[0, 0].plot(y1, y2, color = 'cornflowerblue', lw = 2)
ax[0, 0].set_xlim(-3, 3)
ax[0, 0].set_ylim(-3, 3)

# subplot(222)
rectangle = ax[0, 1].patch
rectangle.set_facecolor('gold')
ax[0, 1].plot(y1, y2, color = 'cornflowerblue', lw = 2)
ax[0, 1].set_xlim(-3, 3)
ax[0, 1].set_ylim(-3, 3)
ax[0, 1].set_aspect('equal', 'box')

# subplot(223)
rectangle = ax[1, 0].patch
rectangle.set_facecolor("palegreen")
ax[1, 0].plot(y1, y2, color = "cornflowerblue", lw = 2)
ax[1, 0].axis("equal")

# subplot(224)
rectangle = ax[1, 1].patch
rectangle.set_facecolor("lightskyblue")
ax[1, 1].plot(y1, y2, color = "cornflowerblue", lw = 2)
ax[1, 1].axis([-3, 3, -3, 3])
ax[1, 1].set_yticks(np.arange(-3, 4, 1))
ax[1, 1].axis("equal")
plt.subplots_adjust(left = 0.1)
plt.show()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

fig, ax = plt.subplots(1, 1, subplot_kw = {'aspect':'equal'})
circle = Circle((2, 2), radius = 1)
angles = np.linspace(0, 135, 4)
ellipse = [Ellipse((2, 2), 2, 2, a) for a in angles]
ellipse.append(circle)
polygon = ellipse

for pln in polygon:
    ax.add_patch(pln)
    pln.set_alpha(float(np.random.rand(1)))
    pln.set_color(np.random.rand(3))

ax.axis([0, 4, 0, 4])
ax.set_xticks(np.arange(0, 5, 1))
ax.set_yticks(np.arange(0, 5, 1))

plt.show()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

fig, ax = plt.subplots(subplot_kw = {'aspect':'equal'})
font_style = {'family':'serif', 'size':12, 'style':'italic', 'weight':'black'}
sample_data = [350, 150, 200, 300]
total = sum(sample_data)
percents = [i/float(total) for i in sample_data]
angles = [360*i for i in percents]
delta = 45
wedge1 = Wedge((2,2), 1, delta, delta+sum(angles[0:1]), color = 'orange')
wedge2 = Wedge((2,1.9), 1, delta+sum(angles[0:1]), delta+sum(angles[0:2]), facecolor = 'steelblue', edgecolor = 'white')
wedge3 = Wedge((2,1.9), 1, delta+sum(angles[0:2]), delta+sum(angles[0:3]), facecolor = 'darkred', edgecolor = 'white')
wedge4 = Wedge((2,1.9), 1, delta+sum(angles[0:3]), delta+sum(angles[0:4]), facecolor = 'lightgreen', edgecolor = 'white')

wedges = [wedge1, wedge2, wedge3, wedge4]
for wedge in wedges:
    ax.add_patch(wedge)
    
ax.text(1.5, 2.5, "%3.1f%%" % (percents[0]*100), font_style)
ax.text(1.0, 1.7, "%3.1f%%" % (percents[1]*100), font_style)
ax.text(1.5, 1.2, "%3.1f%%" % (percents[2]*100), font_style)    
ax.text(2.2, 1.7, "%3.1f%%" % (percents[3]*100), font_style)    
    
ax.axis([0, 4, 0, 4])
plt.show()

 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

fig, ax = plt.subplots(subplot_kw = {'aspect':'equal'})
font_style = {'family':'serif', 'size':9, 'style':'italic', 'weight':'black'}
sample_data = [350, 150, 200, 300]
total = sum(sample_data)
percents = [i/float(total) for i in sample_data]
angles = [360*i for i in percents]
delta = 45
wedge1 = Wedge((2,1.9), 1, delta, delta+sum(angles[0:1]), facecolor = 'orange',
              edgecolor = 'white', width = 0.3)
wedge2 = Wedge((2,1.9), 1, delta+sum(angles[0:1]), delta+sum(angles[0:2]),
               facecolor = 'steelblue', edgecolor = 'white', width = 0.3)
wedge3 = Wedge((2,1.9), 1, delta+sum(angles[0:2]), delta+sum(angles[0:3]),
               facecolor = 'darkred', edgecolor = 'white', width = 0.3)
wedge4 = Wedge((2,1.9), 1, delta+sum(angles[0:3]), delta+sum(angles[0:4]),
               facecolor = 'lightgreen', edgecolor = 'white', width = 0.3)
rectangle = Rectangle((3.0, 0.0), 1.3, 1.3, facecolor = 'w', edgecolor = 'rosybrown')
rectangle1 = Rectangle((3.2, 0.1), 0.3, 0.2, facecolor = 'orange')
rectangle2 = Rectangle((3.2, 0.4), 0.3, 0.2, facecolor = 'steelblue')
rectangle3 = Rectangle((3.2, 0.7), 0.3, 0.2, facecolor = 'darkred')
rectangle4 = Rectangle((3.2, 1.0), 0.3, 0.2, facecolor = 'lightgreen')
                       
wedges = [wedge1, wedge2, wedge3, wedge4, rectangle, rectangle1, rectangle2, rectangle3, rectangle4]
for wedge in wedges:
    ax.add_patch(wedge)

ax.text(3.6, 0.1, "%3.1f%%" % (percents[0]*100), font_style)
ax.text(3.6, 0.4, "%3.1f%%" % (percents[1]*100), font_style)
ax.text(3.6, 0.7, "%3.1f%%" % (percents[2]*100), font_style)    
ax.text(3.6, 1.0, "%3.1f%%" % (percents[3]*100), font_style)    
    
ax.axis([0, 4.5, -0.5, 4])
plt.show()

 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

import numpy as np
import matplotlib.pyplot as plt

fig, ax = plt.subplots()

num = 50

# new sample
sample = 10*np.random.rand(num, 2)
var1 = sample[:, 0]
var2 = sample[:, 1]

# threshold value
td = 12

# discriminant function
df = 2*var1+var2

cates11 = np.ma.masked_where(df>=td, var1)
cates12 = np.ma.masked_where(df>=td, var2)

cates21 = np.ma.masked_where(df<=td, var1)
cates22 = np.ma.masked_where(df<=td, var2)

ax.scatter(var1, var2, s = cates11*50, marker = 's'把, c = cates11)
ax.scatter(var1, var2, s = cates21*50, marker = 'o', c = cates21)

ax.plot(var1, -2*var1+12, lw = 1, color = 'b', alpha = 0.65)
ax.axis([-1, 11, -1, 11])
plt.show()

 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

import datetime
import matplotlib.dates as mdates

fig, ax = plt.subplots()
months = mdates.MonthLocator()  # a Locator instance
dateFmt = mdates.DateFormatter('%m/%d/%y')  # a Formatter instance

# format the ticks
ax.xaxis.set_major_formatter(dateFmt)
ax.xaxis.set_minor_locator(months)

# set appearance parameters for ticks, ticklabels, and gridlines
ax.tick_params(axis = 'both', direction = 'out', labelsize = 10) 

date1 = datetime.date(2008, 4, 17)
date2 = datetime.date(2017, 5, 4)
delta = datetime.timedelta(days = 5)
dates = mdates.drange(date1, date2, delta)

y = np.random.normal(100, 15, len(dates))

ax.plot_date(dates, y, 'b-', alpha = 0.7)

fig.autofmt_xdate()

plt.show()

 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

import matplotlib as mpl

mpl.rcParams['font.sans-serif'] = ['FangSong']
mpl.rcParams['axes.unicode_minus'] = False

mu = 60.2
sigma = 2.0
x = mu + sigma*np.random.randn(500)

bins = 50

fig, ax = plt.subplots(1, 1)

n, bins, patches = ax.hist(x, bins, density = True, stacked = True, histtype = 'bar',
                           facecolor = 'cornflowerblue', edgecolor = 'white', alpha = 0.75)
y = ((1/(np.power(2*np.pi, 0.5)*sigma))*np.exp(-0.5*np.power((bins-mu)/sigma, 2)))

ax.plot(bins, y, color= 'orange', ls = '--', lw = 2)

ax.grid(ls = ':', lw = 1, color = 'gray', alpha = 0.2)

ax.text(54, 0.2, r"$y=\frac{1}{\sigma\sqrt{2\pi}}e^{-\frac{{x-\mu}^2}{2\sigma^2}}$",
        {'color':'r', 'fontsize':20})
ax.set_xlabel('体重')
ax.set_ylabel('概率密度')
ax.set_title(r'体重的直方图：$\mu=60.0$, $\sigma=2.0$', fontsize = 16)

plt.show()

 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

from matplotlib.patches import Polygon

mu = 60.2
sigma = 2.0
x = mu + sigma*np.random.randn(500)

bins = 50

fig, ax = plt.subplots(1, 1)

n, bins, patches = ax.hist(x, bins, density = True, stacked = True, histtype = 'bar',
                           facecolor = 'cornflowerblue', edgecolor = 'white', alpha = 0.75)

y = ((1/(np.power(2*np.pi, 0.5)*sigma))*np.exp(-0.5*np.power((bins-mu)/sigma, 2)))

ax.plot(bins, y, color= 'orange', ls = '--', lw = 2)

integ_x = np.linspace(mu-2*sigma, mu+2*sigma, 1000)
integ_y = ((1/(np.power(2*np.pi, 0.5)*sigma))*np.exp(-0.5*np.power((integ_x-mu)/sigma, 2)))
area = [(mu-2*sigma, 0), *zip(integ_x, integ_y), (mu+2*sigma, 0)]

poly = Polygon(area, facecolor = 'gray', edgecolor = 'k', alpha = 0.6, closed = False)
ax.add_patch(poly)

ax.grid(ls = ':', lw = 1, color = 'gray', alpha = 0.2)

ax.text(54, 0.2, r"$y=\frac{1}{\sigma\sqrt{2\pi}}e^{-\frac{{x-\mu}^2}{2\sigma^2}}$",
        {'color':'r', 'fontsize':20})
ax.set_xlabel('体重')
ax.set_ylabel('概率密度')
ax.set_title(r'体重的直方图：$\mu=60.0$, $\sigma=2.0$', fontsize = 16)

plt.text(0.45, 0.2, r"$\int_{\mu-2\sigma}^{\mu+2\sigma} y\mathrm{d}x$", fontsize = 20,
         transform = ax.transAxes)

plt.show()

 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

mu = 75.0
sigma = 15.0
bins = 20
x = np.linspace(1, 100, 200)
y = np.random.normal(mu, sigma, 200)

fig, ax = plt.subplots()

# the main axes
ax.plot(x, y, ls = '-', lw = 2, color = 'steelblue')
ax.set_ylim(10, 170)

# this is an inset axes over the main axes
plt.axes([0.2, 0.6, 0.2, 0.2], facecolor = 'k')
count, bins, patches = plt.hist(y, bins, color = 'cornflowerblue')
plt.ylim(0, 28)
plt.xticks([])
plt.yticks([])

# this is an inset axes over the inset axes
plt.axes([0.21, 0.72, 0.05, 0.05])
y1 = (1/(sigma*np.sqrt(2*np.pi)))*np.exp(-(bins-mu)**2/(2*sigma**2))
plt.plot(bins, y1, ls = '-', color = 'r')
plt.xticks([])
plt.yticks([])

# this is another inset axes over the main axes
plt.axes([0.65, 0.6, 0.2, 0.2], fc = 'k')
aount, bins, patches = plt.hist(y, bins, color = 'cornflowerblue', density = True, stacked = True,
                                cumulative = True, histtype = 'step')
plt.ylim(0, 1.0)
plt.xticks([])
plt.yticks([])

# this is another inset axes over another inset axes
plt.axes([0.66, 0.72, 0.05, 0.05])
y2 = (1/(sigma*np.sqrt(2*np.pi)))*np.exp(-(bins-mu)**2/(2*sigma**2))
y2 = y2.cumsum()
y2 = y2/y2[-1]
plt.plot(bins, y2, ls = '-', color = 'r')
plt.xticks([])
plt.yticks([])

plt.show()

 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

fig, ax = plt.subplots()

# tick every 5th easter
rule = mdates.rrulewrapper(mdates.YEARLY, byeaster = 0, interval = 2)
loc = mdates.RRuleLocator(rule)  # a Locator instance

dateFmt = mdates.DateFormatter('%m/%d/%y')  # a Formatter instance

# format the ticks
ax.xaxis.set_major_locator(loc)
ax.xaxis.set_major_formatter(dateFmt)

# set appearance parameters for ticks, ticklabels, and fridlines
ax.tick_params(axis = 'both', direction = 'out', labelsize = 10)

date1 = datetime.date(2004, 5, 17)
date2 = datetime.date(2016, 6, 4)
delta = datetime.timedelta(days = 5)
dates = mdates.drange(date1, date2, delta)

y = np.random.normal(120, 12, len(dates))

ax.plot_date(dates, y, 'b-', alpha = 0.7)

fig.autofmt_xdate()

plt.show()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

import numpy as np
from matplotlib.patches import Rectangle
import matplotlib.patches as patches
import matplotlib.pyplot as plt
from jupyterthemes import jtplot
jtplot.style(theme='grade3', context='paper')

fig = plt.figure(1, figsize = (8, 9), dpi = 72)
fontsize = 0.25*fig.dpi

# subplot(111)
ax = fig.add_subplot(1, 1, 1, frameon = False, xticks = [], yticks = [])

boxStyles = patches.BoxStyle.get_styles()
boxStyleNames = list(boxStyles.keys())
boxStyleNames.sort()

for i, name in enumerate(boxStyleNames):
    ax.text(float(i + 0.5)/len(boxStyleNames), (float(len(boxStyleNames))-0.5-i)/len(boxStyleNames),
            name, ha = 'center', size = fontsize, transform = ax.transAxes,
            bbox = dict(boxstyle = name, fc = 'w', ec =  'k'))
plt.show()

 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

fig = plt.figure(1, figsize = (8, 9), dpi = 72)
fontsize = 0.23*fig.dpi

# subplot(111)
ax = fig.add_subplot(1, 1, 1, frameon = False)
arrowStyles = patches.ArrowStyle.get_styles()
arrowStyleNames = list(arrowStyles)
arrowStyleNames.sort()

ax.set_xlim(0, len(arrowStyleNames)+2.5)
ax.set_ylim(-2, len(arrowStyleNames))

for i, name in enumerate(arrowStyleNames):
    p = patches.Circle((float(len(arrowStyleNames))+1.2-i, float(len(arrowStyleNames))-2.8-i),
                        0.2, color = 'steelblue', alpha = 1.0)
    ax.add_patch(p)
    ax.annotate(name,
                (float(len(arrowStyleNames))+1.2-i, float(len(arrowStyleNames))-2.8-i),
                (float(len(arrowStyleNames))-1-i, float(len(arrowStyleNames))-3-i),
                xycoords = 'data', ha = 'center', size = fontsize,
                arrowprops = dict(arrowstyle = name, facecolor = 'k', edgecolor = 'k', patchB = p,
                                  shrinkA = 5, shrinkB = 5, connectionstyle = 'arc3'),
                bbox = dict(boxstyle = 'round', fc = 'w', ec = 'k'))
    
    ax.xaxis.set_visible(False)  # ax.set_xticks([])
    ax.yaxis.set_visible(False)  # ax.set_yticks([])
plt.savefig('xxx.tif', dpi = 300)

 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

fig = plt.figure(1, figsize = (8, 8), dpi = 80, facecolor = 'w')
fontsize = 0.3*fig.dpi
font_style = {'family':'sans-serif', 'fontsize':fontsize, 'weight':'black'}

# add axes in axis coords
ax = fig.add_axes([0.0, 0.0, 1.0, 1.0], fc = 'gold')

left = 0.2
bottom= 0.2
right = 0.8
top = 0.8
width = right-left
height = top-bottom

# add a rectangle in axis coords
rect = Rectangle((left, bottom), width, height, transform = ax.transAxes, facecolor = 'w', edgecolor = 'k')
ax.add_patch(rect)

# add text in axis coords
#  left-bottom
ax.text(left, bottom, 'left bottom', ha = 'left', va = 'bottom', transform = ax.transAxes, **font_style)

# left top
ax.text(left, bottom, 'left top', ha = 'left', va = 'top', transform = ax.transAxes, **font_style)

# right-bottom
ax.text(right, top, 'right bottom', ha = 'right', va = 'bottom', transform = ax.transAxes, **font_style)

# right top
ax.text(right, top, 'right top', ha = 'right', va = 'top', transform = ax.transAxes, **font_style)

# center top
ax.text(right, bottom, 'center top', ha = 'center', va = 'top', transform = ax.transAxes, **font_style)

# center bottom
ax.text(right, bottom, 'center bottom', ha = 'center', va = 'bottom', transform = ax.transAxes, **font_style)

# left center
ax.text(left, top, 'left center', ha = 'left', va = 'center', transform = ax.transAxes, **font_style)

# right center
ax.text(right, 0.5, 'right center', ha = 'right', va = 'center', transform = ax.transAxes, rotation = 90, **font_style)

# center center
ax.text(left, 0.5, 'center center', ha = 'center', va = 'center', transform = ax.transAxes, rotation = 90,  **font_style)

# middle
ax.text(0.5, 0.5, 'middle', ha = 'center', va = 'center', transform = ax.transAxes, color = 'r', **font_style)

# rotated center-center
# left-center
ax.text(left*0.7, top + 0.05, 'rotated\ncenter center', ha = 'center', va = 'center', transform = ax.transAxes,
        rotation = 45,  **font_style)

plt.show()

 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

fig = plt.figure(1, figsize = (8, 8), dpi = 80, facecolor = 'w')

# add axes in axis coords
ax = fig.add_axes([0.0, 0.0, 1.0, 1.0], fc = 'gold')

left = 0.2
bottom= 0.2
right = 0.8
top = 0.8
width = right-left
height = top-bottom

the_zen_of_Python = """Explicit is better than implicit. Complex is better than complicated."""

# add a rectangle in axis coords
rect = Rectangle((left, bottom), width, height, transform = ax.transAxes, facecolor = 'w', edgecolor = 'k')
ax.add_patch(rect)                 
                 
ax.text(0.5, 1, the_zen_of_Python, transform = ax.transAxes, fontsize = 18, weight = 'black', ha = 'center',
              va = 'top', wrap = True)._get_wrap_line_width = lambda : 200.

ax.text(0.5*width, 0.5, the_zen_of_Python, transform = ax.transAxes, fontsize = 10, weight = 'black', ha = 'right',
              rotation = 20, style = 'italic', family = 'monospace', wrap = True)._get_wrap_line_width = lambda : 150.

ax.text(left, bottom, the_zen_of_Python, transform = ax.transAxes, fontsize = 15, weight = 'bold', ha = 'left', va = 'center',
              rotation = -15, style = 'oblique', family = 'serif', wrap = True)._get_wrap_line_width = lambda : 600.

ax.text(width, 0.5*height, the_zen_of_Python, transform = ax.transAxes, fontsize = 18, weight = 'bold', ha = 'left',
              rotation = 15, style = 'normal', family = 'sans-serif', wrap = True)._get_wrap_line_width = lambda : 250.

plt.show()

 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

import matplotlib.text as mtext
import matplotlib.transforms as mtransforms

class RotationAwareAnnotation(mtext.Annotation):
    def __init__(self, s, xy, p, pa=None, ax=None, **kwargs):
        self.ax = ax or plt.gca()
        self.p = p
        if not pa:
            self.pa = xy
        self.calc_angle_data()
        kwargs.update(rotation_mode=kwargs.get("rotation_mode", "anchor"))
        mtext.Annotation.__init__(self, s, xy, **kwargs)
        self.set_transform(mtransforms.IdentityTransform())
        if 'clip_on' in kwargs:
            self.set_clip_path(self.ax.patch)
        self.ax._add_text(self)

    def calc_angle_data(self):
        ang = np.arctan2(self.p[1]-self.pa[1], self.p[0]-self.pa[0])
        self.angle_data = np.rad2deg(ang)

    def _get_rotation(self):
        return self.ax.transData.transform_angles(np.array((self.angle_data,)), 
                            np.array([self.pa[0], self.pa[1]]).reshape((1, 2)))[0]

    def _set_rotation(self, rotation):
        pass

    _rotation = property(_get_rotation, _set_rotation)


fig, ax = plt.subplots()
t = np.arange(0.0, 1.0, 0.01)
line, = ax.plot(t, t, color='blue', lw=2)

ra = RotationAwareAnnotation("ticklabel Rule", xy=(.5,.5), p=(.6,.6), ax=ax,
                             xytext=(2,-1), textcoords="offset points", va="top")