文讨论的内容是PostgreSQL中，高效生成序列化数字和ID的机制： Sequence，就是序列。

什么是Sequence

Sequence的英文意为“序列”，就是一个有序的、可以单调递增的整数序列。

在Postgres中， Sequence是一个序列数字的生成器。在使用前，需要先创建一个序列的实例，然后可以将这个实例作为数据类型，应用到数据库表字段定义当中。当然，也可以直接使用序列相关的操作方法，如从序列实例中获取下一个值或者当前值，来支持特定的业务应用需求。

在数据库应用中，序列技术最常用的场景，就是辅助生成一个数据库级别的不重复的编号，可以作为一个标识。这一就可以解决了数据库表中，记录主键或者唯一标识的问题。

如果没有系统级内置的序列机制的话，在程序级别的实现是比较麻烦的。例如，需要查询表中，最大的记录ID，然后加1作为新值；或者随机生成一个ID，再检查表中是否有重复的信息；或者使用一个ID记录表，批量生成后，使用并标记可用的ID；再有就是使用UUID的机制。这些实现，相对而言都比较麻烦，而且代价也比较高昂。

Postgres中，如何使用序列

Postgres官方技术文档的序列章节的链接如下：

https://www.postgresql.org/docs/16/sql-createsequence.html

在Postgres中使用序列，一般涉及以下相关操作。

创建序列实例

以下的语句，可以在数据库中，创建一个序列实例：

CREATE SEQUENCE sq_common
  START 1
  INCREMENT 1
  MINVALUE 1
  MAXVALUE 200000000
  CACHE 10;
CREATE SEQUENCE

-- 简单写法
CREATE SEQUENCE sq_common;

-- 完整的语法
CREATE [ { TEMPORARY | TEMP } | UNLOGGED ] SEQUENCE [ IF NOT EXISTS ] name
    [ AS data_type ]
    [ INCREMENT [ BY ] increment ]
    [ MINVALUE minvalue | NO MINVALUE ] [ MAXVALUE maxvalue | NO MAXVALUE ]
    [ START [ WITH ] start ] [ CACHE cache ] [ [ NO ] CYCLE ]
    [ OWNED BY { table_name.column_name | NONE } ]

这里的要点如下：

• 语句定义了一个名为 sq_common的序列实例
• 可以定义起始值(默认1)、最小值、最大值、步进值(默认为1)
• 简单的写法，只需要指定一个名称
• 缓存值和序列生成的缓存机制，可以帮助提高序列生成和使用的性能
• 在Postgres中，本质上序列的值就是一个bigint整数，其限制就是bigint的取值范围，当然用户可以指定其范围
• 可以使用CYCLE指定序列是否可以循环取值(用完后从头开始)

数据库字段

使用以下语句和方法，创建一个使用序列的数据库表：

CREATE TABLE my_table (
  id INTEGER PRIMARY KEY DEFAULT NEXTVAL('sq_common'),
  name VARCHAR(50)
);

\d my_table
                                Table "public.my_table"
 Column |         Type          | Collation | Nullable |            Default             
--------+-----------------------+-----------+----------+--------------------------------
 id     | integer               |           | not null | nextval('sq_common'::regclass)
 name   | character varying(50) |           |          | 
Indexes:
    "my_table_pkey" PRIMARY KEY, btree (id)

从描述信息来看，和想象的不同，并不是说直接指定字段使用这个序列实例，而是先设置字段类型是interger，然后指定其默认值，来调用一个nextval()方法，方法的参数就是序列实例的名称。这一，在插入新行的时候，这个字段如果没有设置值，则会调用序列方法，获取序列中下一个值，作为这个字段的值。

注意这里nextval中的参数的完整定义，类型是regclass。也说就是，实际nextval的参数，是一个对象，regclass转换可以使用名称来映射这个对象，作为参数。

在这个例子中，利用序列实例，定义了一个主键字段。使用同样的道理，还可以利用序列定义其他的不重复编码的值的字段。此外，由于这种使用方式，我们也可以在不同的表中，共享这个序列。

序列值操作

上面定义数据库表字段的示例中，我们已经看到，可以使用相关的函数来获得序列实例中的下一个值。关于这种类似的序列操作的函数包括：

• nextval() 获取序列实例的下一个序列值，而且当函数调用时，序列实例中的当前值会自动步进
• currval() 获取序列实例当前值，同时序列不会步进
• setval() 给序列设置当前值，可选获取下一个值或者当前值
• lastval() 获取当前session中，最后一个由序列生成的值(注意不需要指定实例)

下面是相关代码示例：

-- 下一值
defaultdb=> select nextval('sq_common');
 nextval 
---------
       3
(1 row)

-- 当前值
defaultdb=> select currval('sq_common');
 currval 
---------
       3
(1 row)

-- 设置值
defaultdb=> SELECT setval('sq_common', 42); 
 setval 
--------
     42
(1 row)

defaultdb=> SELECT setval('sq_common', 42, false); 
 setval 
--------
     42
(1 row)


-- 利用序列来编码
 select 'CODE-' ||  LPAD('' || nextval('sq_common'),5,'0');
  ?column?  
------------
 CODE-00007
(1 row)

序列实例管理

在序列实例创建之后，可以使用相关语句对其进行管理。

• ALTER SEQUENCE 修改序列实例的起始、步进、最大值和最小值

简单示例如下：

-- 修改起始值
alter sequence sq_common  start 1001;
ALTER SEQUENCE

-- 删除实例
drop sequence sq_common;
ERROR:  cannot drop sequence sq_common because other objects depend on it
DETAIL:  default value for column id of table my_table depends on sequence sq_common
HINT:  Use DROP ... CASCADE to drop the dependent objects too.

这里修改了start值后，其实对序列当前值并没有直接的影响。也许如果可以循环，它会以这个值作为起始吧。如果确实需要修改序列当前的值，需要使用setval方法。

• DROP SEQUENCE 删除序列实例

要注意删除的时候，对使用该实例的表的影响(上例)。例如，如果序列在被使用的时候，其实是不能直接删除的。相关的错误信息可以清晰的指出操作失败的原因和位置。

如何查询序列的状态

有趣的是，作为一个数据库对象，可以直接使用select语句，来查询序列实例的状态。

SELECT * FROM sq_common;
 last_value | log_cnt | is_called 
------------+---------+-----------
          3 |      30 | t
(1 row)

在Postgres中，有一个serial数据类型，和序列是什么关系

笔者理解，这实际上是一个语法糖，或者批处理标识。目的是简化表的定义，因为这是一种比较常见的需求。

具体操作过程应该是这样的。系统如果发现定义字段的类型是serial，在创建表时，就会使用默认设置和命名规则，先创建一个序列实例，然后使用这个序列实例名称，设置到字段默认值的定义当中。

比如上面的例子，可以简化为：

defaultdb=> CREATE TABLE my_table2 (
  id SERIAL PRIMARY KEY,
  name VARCHAR(50)
);
CREATE TABLE

defaultdb=> \d my_table2;
                                   Table "public.my_table2"
 Column |         Type          | Collation | Nullable |                Default                
--------+-----------------------+-----------+----------+---------------------------------------
 id     | integer               |           | not null | nextval('my_table2_id_seq'::regclass)
 name   | character varying(50) |           |          | 
Indexes:
    "my_table2_pkey" PRIMARY KEY, btree (id)

这样就简单了很多，而且效果基本一样。

创建Sequence语句中，有两个关键字Temp和Unlogged是做什么的

Temp关键字，可以指定当前创建的序列是一个临时序列，只对当前会话有效，有点像Temp Table的意思。

Unlogged关键字，该设置将创建为不记录的序列。也就是说，对序列所做的修改，不会写到日志中。如果系统崩溃或者意外关闭，这个序列会重置到初始状态。但意外的是，这个设置并没有提供显著的性能优势(比如unlogged insert)，主要用于配合非日志记录的表来使用。实际应用中，应该没有机会接触到这种场景。

使用序列需要注意什么问题

笔者在日常使用序列，觉得有一些观点和经验可以分享一些：

• SQL语句中，是可以直接使用序列函数的
• 如果没有其他的特别原因，可以考虑共享序列
• 序列不仅仅可以用于标识字段，也可以通过配合字符串函数，作为不重复编码的生成方式
• 在做数据迁移的时候，要特别注意序列实例一般是无法迁移的，可能需要一些手动的处理和操作
• 不同系统中的序列，特别是迁移的序列的值，要特别注意其一致性
• 需要理解，序列对象实例，和数据库字段的值没有直接的逻辑联系，只是借助了序列操作结果而已，所以特别要注意在修改序列状态的时候，可能对字段值造成的取值冲突
• 序列值是可以不连续的(修改步长不为1)，虽然好像没有特别的理由这么做
• 作为系统级别的实现，应当优先使用序列作为不重复值生成机制

小结

在Postgres中，序列是一种系统级别的高效生成序列化数组的机制。本文讨论了这个机制相关实现和操作的过程，相关数据类型和数据字段的定义，相关函数的使用方法和场景，以及需要注意的问题等内容。

作者：JohnYan

链接：https://juejin.cn/post/7389579792510943295

#记录我的2024#

"""
Sequence 抽象基类
它继承了Sized Iterable Contain 这三个抽象基类
"""
class Sequence(Sized, Iterable, Container):
 """All the operations on a read-only sequence.
 Concrete subclasses must override __new__ or __init__,
 __getitem__, and __len__.
 """
 __slots__=()
 
 @abstractmethod
 def __getitem__(self, index):
 raise IndexError
 
 def __iter__(self):
 i=0
 try:
 while True:
 v=self[i]
 yield v
 i +=1
 except IndexError:
 return
 
 def __contains__(self, value):
 for v in self:
 if v==value:
 return True
 return False
 
 def __reversed__(self): # 该魔法函数使得序列类型可以反转
 for i in reversed(range(len(self))):
 yield self[i]

class Sized(metaclass=ABCMeta):
 __slots__=()
 
 @abstractmethod
 def __len__(self): # 这个魔法函数使得序列类型可以使用 len()获得长度
 return 0
 
 @classmethod
 def __subclasshook__(cls, C):
 if cls is Sized:
 if any("__len__" in B.__dict__ for B in C.__mro__):
 return True
 return NotImplemented

class Iterable(metaclass=ABCMeta):
 __slots__=()
 
 @abstractmethod
 def __iter__(self): # 这个魔法函数使得序列类型可以进行 for 循环
 while False:
 yield None
 
 @classmethod
 def __subclasshook__(cls, C):
 if cls is Iterable:
 if any("__iter__" in B.__dict__ for B in C.__mro__):
 return True
 return NotImplemented

class Container(metaclass=ABCMeta):
 __slots__=()
 
 @abstractmethod
 def __contains__(self, x): # 这个魔法函数使得序列类型可以使用 in 操作符
 return False
 
 @classmethod
 def __subclasshook__(cls, C):
 if cls is Container:
 if any("__contains__" in B.__dict__ for B in C.__mro__):
 return True
 return NotImplemented

class MutableSequence(Sequence):
 __slots__=()
 """All the operations on a read-write sequence.
 Concrete subclasses must provide __new__ or __init__,
 __getitem__, __setitem__, __delitem__, __len__, and insert().
 """
 @abstractmethod
 def __setitem__(self, index, value):
 raise IndexError
 
 @abstractmethod
 def __delitem__(self, index):
 raise IndexError
 
 def __iadd__(self, values): # 使得序列可以使用 +=运算符号进行计算
 self.extend(values)
 return self
 
 # ......只列出几个有代表意义的魔法函数......
 # 这些魔法函数使得序列类型可以改变

"""
普通的加法会在内存中产生一个新的序列对象
时间 空间开销相对比较大
必须要是类型完全一致才能够使用这种合并方式
"""
a, b, c=[1, 2], [3, 4], (5, 6)
d=a + b # [1, 2] + [3, 4]
print(d)
# result:
# [1, 2, 3, 4]
d=a + c # [1, 2] + (5, 6)
print(d)
# result:
# TypeError: can only concatenate list (not "tuple") to list

"""
+=可以理解为原地加，单纯地在原对象上进行修改，效率比 + 要高很多
这个功能背后有一个魔法函数，__iadd__(self, values)
上一小节中有这个函数具体的实现，我们可以看到，它是调用了 extend()方法
所以本质上，它和调用 extend()函数产生的效果是一模一样的
"""
a, b, c=[1, 2], [3, 4], (5, 6)
a +=b
print(a)
# result:
# [1, 2, 3, 4]
a +=c
print(a)
# result:
# [1, 2, 3, 4, 5, 6]

# 使用模式：[start:end:step]
"""
start: 切片开始的位置，默认是 0
end: 切片截止（不包括）的位置，默认是列表长度
step: 切片的步长，默认是 1
start和end为默认值时可以省略不写，step为默认值时可以连同最后的冒号一起省略
step为负数时，表示反向切片，此时需满足： start > end
"""

li=[8, 4, 3, 2, 1, 7]
li[::] # 返回原序列
li[::-1] # 返回原序列的逆序列表
li[::2] # 隔一个取一个，所有偶数位置
li[1::2] # 隔一个取一个，所有奇数位置
li[3:6] # 取[3, 6)区间内的所有元素，左包含，右不包含
li[0:666] # 结束位置大于列表长度，从尾部截断，返回原列表
li[666:] # 开始位置大于列表长度，直接返回空列表
li=[6, 6]
li[:0]=[1, 2] # 列表头部插入元素 [1, 2, 6, 6]
li[1:1]=[1, 1] # 列表的某一位置插入元素 [6, 1, 1, 6]
li[:1]=[1, 1] # 替换列表元素 [1, 1, 6]
li[1:]=[1, 1] # 替换列表元素 [6, 1, 1]

class Group:
 def __init__(self, group_name, staffs):
 self.group_name=group_name
 self.staffs=staffs
 
 def __reversed__(self): # reversed(group)
 self.staffs.reverse()
 
 """
 在使用切片和索引访问操作时，相关的参数会传递到 __getitem__(self, item) 中
 我们通常希望，切片返回的对象和原对象是同一种类型
 使用切片的话，传入的item是一个slice类型
 使用索引访问，传入的item是一个int类型
 """
 def __getitem__(self, item): # 对象可切片的关键
 cls=type(self) # 获得该实例的类型
 if isinstance(item, slice):
 return cls(self.group_name, self.staffs[item]) # 委托给列表实现切片
 elif isinstance(item, int):
 return self.staffs[item]
 
 def __len__(self):
 return len(self.staffs)
 
 def __iter__(self):
 return iter(self.staffs) # 后面会详细讲解
 
 def __contains__(self, item):
 return item in self.staffs # 同样委托给列表的in操作来实现
 
 def __str__(self):
 return "name:{name}\nstaffs:{staffs}".format(name=self.group_name, staffs=self.staffs)
staffs=["MetaTian0", "MetaTian1", "MetaTian2"]
group=Group("HIT", staffs)
print(group[1]) # 索引访问
print(group[0:2]) # 切片
reversed(group) # 反转
print(group)
print(len(group)) # 长度
print("MetaTian0" in group, "MetaTian6" in group) # in 操作符
# resutl:
# MetaTian1
# name:HIT; staffs:['MetaTian0', 'MetaTian1']
# name:HIT; staffs:['MetaTian2', 'MetaTian1', 'MetaTian0']
# 3
# True False

import bisect
int_list=[]
"""
在插入过程中维护序列的有序性
"""
bisect.insort(int_list, 2)
bisect.insort(int_list, 6)
bisect.insort(int_list, 1)
bisect.insort(int_list, 3)
bisect.insort(int_list, 5)
print(int_list)
# result:
# [1, 2, 3, 5, 6]
"""
查询一个元素在序列中应该插入的位置
bisect(): 同值元素默认插在右侧
bisect_left(): 同值元素默认插在左侧
"""
print(bisect.bisect(int_list, 3))
print(bisect.bisect_left(int_list, 3))
# result:
# 3
# 2

import array
"""
使用前要引入array模块，要申明存储的对象类型
"""
my_array=array.array("i")
my_array.append(666)
my_array.append(4)
my_array.extend([1, 2, 3])
my_list=my_array.tolist()
# 大部分基本的操作函数和序列差不多，这里就不做过多介绍
print(my_array)
# result:
# array('i', [666, 4, 1, 2, 3])
# [666, 4, 1, 2, 3]

"""
列表推导
生成1-20中的奇数
"""
# 普通方式
odd_list=[]
for i in range(1, 21):
 if i%2==1:
 odd_list.append(i)
# 列表推导
odd_list=[i for i in range(1, 21) if i%2==1]
"""
生成器表达式
后面部分会详细介绍其原理
"""
odd_list=(i for i in range(1, 21) if i%2==1)
print(type(odd_list))
# result:
# <class 'generator'>
for item in odd_list:
 print(item, end=' ')
 
# result:
# 1 3 5 7 9 11 13 15 17 19 
"""
字典推导式
"""
my_dict={"a":1, "b":2, "c":3}
reversed_dict={val:k for k, val in my_dict.items()}
print(reversed_dict)
# result:
# {1: 'a', 2: 'b', 3: 'c'}

读：什么是时间序列？用来展示什么样的数据关系？怎样用Python实现？本文将为你解答。

作者：屈希峰，资深Python工程师，知乎多个专栏作者

来源：华章科技

01 概述

时间序列（Time series）是指将某种现象某一个统计指标在不同时间上的各个数值，按时间先后顺序排列而形成的序列。时间序列法是一种定量预测方法，也称简单外延法，在统计学中作为一种常用的预测手段被广泛应用。

时间序列分析在第二次世界大战前应用于经济预测。“二战”中和“二战”后，在军事科学、空间科学、气象预报和工业自动化等领域的应用更加广泛。

时间序列分析（Time Series Analysis）是一种动态数据处理的统计方法。该方法基于随机过程理论和数理统计学方法，研究随机数据序列所遵从的统计规律，用于解决实际问题。时间序列构成要素是现象所属的时间和反映现象发展水平的指标数值，如下图所示。

时间序列中的每个观察值大小,是影响变化的各种不同因素在同一时刻发生作用的综合结果。从这些影响因素发生作用的大小和方向变化的时间特性来看,这些因素造成的时间序列数据的变动分为如下4种类型。

1. 趋势性：某个变量随着时间进展或自变量变化，呈现出一种比较缓慢而长期的持续上升、下降、停留的同性质变动趋向，但变动幅度可能不相等。
2. 周期性：某因素由于外部影响随着自然季节的交替出现高峰与低谷的规律。
3. 随机性：个别为随机变动，整体呈统计规律。
4. 综合性：实际变化情况是几种变动的叠加或组合。预测时设法过滤除去不规则变动，突出反映趋势性和周期性变动。

02 实例

时间序列代码示例如下所示。

• 代码示例①

 1from?bokeh.sampledata.stocks?import?AAPL??
 2import?numpy?as?np??
 3#?数据??
 4aapl?=?np.array(AAPL['adj_close'])??
 5aapl_dates?=?np.array(AAPL['date'],?dtype=np.datetime64)??
 6window_size?=?30??
 7window?=?np.ones(window_size)/float(window_size)??
 8aapl_avg?=?np.convolve(aapl,?window,?'same')??
 9#?画布??
10p?=?figure(width=800,?height=350,?x_axis_type="datetime")??
11#?图层??
12p.circle(aapl_dates,?aapl,?size=4,?color='darkgrey',?alpha=0.2,?legend='close')??
13p.line(aapl_dates,?aapl_avg,?color='red',?legend='avg')??
14#?自定义属性??
15p.title.text?=?"AAPL?One-Month?Average"??
16p.legend.location?=?"top_left"??
17p.grid.grid_line_alpha=0??
18p.xaxis.axis_label?=?'Date'??
19p.yaxis.axis_label?=?'Price'??
20p.ygrid.band_fill_color="gray"??
21p.ygrid.band_fill_alpha?=?0.1??
22p.legend.click_policy="hide"?#?点击图例显示隐藏数据??
23#?显示结果??
24show(p)??

运行结果如图1所示。

代码示例①第8行np.convolve用来计算离散点的移动平均值；第10行在画布中预定义x轴的数据类型为datetime；第12行绘制离散的点（散点图）；第13行绘制曲线。第15～22行是关于图例、坐标轴的一些自定义属性，将在后文进行详述。

• 代码示例②

 1import?numpy?as?np??
 2from?bokeh.models?import?ColumnDataSource,?CustomJSTransform??
 3from?bokeh.plotting?import?figure??
 4from?bokeh.io?import?output_file,?show??
 5from?bokeh.sampledata.stocks?import?AAPL,?GOOG??
 6from?bokeh.transform?import?transform??
 7#?数据转换为时间类型??
 8def?datetime(x):??
 9??????return?np.array(x,?dtype=np.datetime64)??
10#?画布??
11plot?=?figure(x_axis_type="datetime",?title="Normalized?Stock?Closing?Prices",
12??????????????????????????plot_width=800,?plot_height=350)??
13#?其他??
14plot.background_fill_color?=?"#f0f0f0"??
15plot.xgrid.grid_line_color?=?None??
16plot.ygrid.grid_line_color?=?"black"??
17plot.ygrid.grid_line_alpha?=?0.1??
18plot.xaxis.axis_label?=?'Date'??
19plot.yaxis.axis_label?=?'Normalized?Price'??
20#?数据??
21aapl_source?=?ColumnDataSource(data=dict(??
22????????aapl_date=datetime(AAPL['date']),??
23????????aapl_close=AAPL['adj_close'],??
24))??
25
26goog_source?=?ColumnDataSource(data=dict(??
27????????goog_date=datetime(GOOG['date']),??
28????????goog_close=GOOG['adj_close'],??
29))??
30#?CustomJSTransform??
31v_func?=?"""?
32???????const?first?=?xs[0]?
33???????const?norm?=?new?Float64Array(xs.length)?
34???????for?(let?i?=?0;?i?<?xs.length;?i++)?{?
35?????????????norm[i]?=?xs[i]?/?first?
36???????}?
37???????return?norm?
38"""??
39normalize?=?CustomJSTransform(v_func=v_func)??
40#?绘图??
41plot.line(x='aapl_date',?y=transform('aapl_close',?normalize),?line_width=2,??
42??????????????color='#cf3c4d',?alpha=0.6,legend="Apple",?source=aapl_source)??
43plot.line(x='goog_date',?y=transform('goog_close',?normalize),?line_width=2,??
44????????????color='#2f7bce',?alpha=0.6,?legend="Google",?source=goog_source)??
45plot.legend.location='top_left'??
46#?显示??
47show(plot)??

运行结果如图3所示。

代码示例②第11行在画布中预定义x轴的数据类型为datetime；第41、43行绘制两条时间序列曲线。第31行采用JavaScript函数对y轴数据进行标准化处理，如果对JavaScript函数不熟悉，可以在Pandas中对原始数据进行预处理，然后直接进行调用。

• 代码示例③

 1from?bokeh.models?import?BoxAnnotation??
 2from?bokeh.sampledata.glucose?import?data?as?data_or??
 3import?numpy?as?np????
 4#?工具条??
 5TOOLS?=?"pan,wheel_zoom,box_zoom,reset,save"??
 6#?数据??
 7data?=?data_or.sort_index()['2010-03-24':'2010-03-25']??
 8#?画布??
 9p?=?figure(x_axis_type="datetime",?tools=TOOLS,?title="Glocose?Readings,?Oct?4th?(Red?=?Outside?Range)")??
1010.???
11#?绘图??
12p.line(np.array(data.index.tolist(),?dtype=np.datetime64),?data.glucose.values,?line_color='gray')??
13p.circle(data.index,?data.glucose,?color='grey',?size=1)??
14#?箱形标记??
15p.add_layout(BoxAnnotation(top=80,?fill_alpha=0.1,?fill_color='red',?line_color='red'))??
16p.add_layout(BoxAnnotation(bottom=180,?fill_alpha=0.1,?fill_color='red',?line_color='red'))??
17#?其他??
18p.background_fill_color?=?"#efefef"??
19p.xgrid.grid_line_color=None??
20p.xaxis.axis_label?=?'Time'??
21p.yaxis.axis_label?=?'Value'??
22show(p)??

运行结果如图3所示。

代码示例③在时间序列曲线的基础上增加了箱形标记，深色区域为需要突出显示的数据，读者仅需要知道这种标记展示方式，后文会详述箱形标记方法。

• 代码示例④

 1import?numpy?as?np??
 2from?bokeh.layouts?import?gridplot??
 3from?bokeh.sampledata.stocks?import?AAPL,?GOOG,?IBM,?MSFT??
 4def?datetime(x):??
 5????return?np.array(x,?dtype=np.datetime64)??
 6#?画布1??
 7p1?=?figure(x_axis_type="datetime",?title="Stock?Closing?Prices")??
 8p1.grid.grid_line_alpha=0.3??
 9p1.xaxis.axis_label?=?'Date'??
10p1.yaxis.axis_label?=?'Price'??
11#?绘图1??
12p1.line(datetime(AAPL['date']),?AAPL['adj_close'],?color='#A6CEE3',?legend='AAPL')
13p1.line(datetime(GOOG['date']),?GOOG['adj_close'],?color='#B2DF8A',?legend='GOOG')
14p1.line(datetime(IBM['date']),?IBM['adj_close'],?color='#33A02C',?legend='IBM')
15p1.line(datetime(MSFT['date']),?MSFT['adj_close'],?color='#FB9A99',?legend='MSFT')
16p1.legend.location?=?"top_left"??
17#?数据2??
18aapl?=?np.array(AAPL['adj_close'])??
19aapl_dates?=?np.array(AAPL['date'],?dtype=np.datetime64)??
20window_size?=?30??
21window?=?np.ones(window_size)/float(window_size)??
22aapl_avg?=?np.convolve(aapl,?window,?'same')??
23#?画布2??
24p2?=?figure(x_axis_type="datetime",?title="AAPL?One-Month?Average")??
25p2.grid.grid_line_alpha?=?0??
26p2.xaxis.axis_label?=?'Date'??
27p2.yaxis.axis_label?=?'Price'??
28p2.ygrid.band_fill_color?=?"olive"??
29p2.ygrid.band_fill_alpha?=?0.1??
30p2.circle(aapl_dates,?aapl,?size=4,?legend='close',??
31???????????????????color='darkgrey',?alpha=0.2)??
32p2.line(aapl_dates,?aapl_avg,?legend='avg',?color='navy')??
33p2.legend.location?=?"top_left"??
34#?显示??
35show(gridplot([[p1,p2]],plot_width=400,?plot_height=400))

运行结果如图4所示。

代码示例④采用网格布局显示两张时间序列曲线，可以对某一曲线进行横向比较。

• 代码示例⑤

 1from?numpy?import?pi,?exp,?linspace,?sin??
 2import?time??
 3from?bokeh.util.browser?import?view??
 4from?bokeh.document?import?Document??
 5from?bokeh.embed?import?file_html??
 6from?bokeh.models.glyphs?import?Circle??
 7from?bokeh.models?import?Plot,?DatetimeAxis,?ColumnDataSource,?PanTool,?WheelZoomTool??
 8from?bokeh.resources?import?INLINE??
 9#?数据??
10N?=?200??
11x?=?linspace(-2?*?pi,?2?*?pi,?N)??
12y?=?sin(x)*exp(-x)??
13#?创建一组时间数据，以当前时间往后延伸24小时??
14times?=?(linspace(0,?24*3600,?N)?+?time.time())?*?1000??
15source?=?ColumnDataSource(data=dict(x=x,?y=y,?times=times))??
16#?画布??
17plot?=?Plot(min_border=80,?plot_width=800,?plot_height=350,?background_fill_color="#efefef")??
18#?绘图??
19circle?=?Circle(x="times",?y="y",?fill_color="red",?size=3,?line_color=None,?fill_alpha=0.5)??
20plot.add_glyph(source,?circle)??
21#?设置时间轴??
22plot.add_layout(DatetimeAxis(),?'below')??
23plot.add_layout(DatetimeAxis(),?'left')??
24#?设置工具条??
25plot.add_tools(PanTool(),?WheelZoomTool(zoom_on_axis=False,?speed=1/5000.))??
26#?显示??
27show(plot)??

运行结果如图5所示。

代码示例⑤采用modes接口进行图形绘制，第25行为该图形增加平移工具并自定义滚轮缩放的速率。读者仅需要了解采用这种方式进行绘图的基本流程即可。

关于作者：屈希峰，资深Python工程师，Bokeh领域的实践者和布道者，对Bokeh有深入的研究。擅长Flask、MongoDB、Sklearn等技术，实践经验丰富。知乎多个专栏（Python中文社区、Python程序员、大数据分析挖掘）作者，专栏累计关注用户十余万人。

本文摘编自《Python数据可视化：基于Bokeh的可视化绘图》，经出版方授权发布。

推荐语：从图形绘制、数据动态展示、Web交互等维度全面讲解Bokeh功能和使用，不含复杂数据处理和算法，深入浅出，适合零基础入门，包含大量案例。