Composable cycles
版本：0.11.0
日期：2021年11月10日
Docs | https://matplotlib.org/cycler |
PyPI | https://pypi.python.org/pypi/Cycler |
GitHub | https://github.com/matplotlib/cycler |
循环器（cycler）API
cycler(*args, **kwargs) | 从单个位置参数、一对位置参数或关键字参数的组合创建新的Cycler对象的函数。 |
Cycler(left[, right, op]) | 可组合循环（Cycler对象）构造器 |
concat(left, right) | 连接Cyclers，就像使用itertools.chain链接一样。 |
cycler的公共API由一个类Cycler、一个工厂函数cycler()和一个连接函数concat()组成。工厂函数提供了一个简单的接口来创建“基本”Cycler对象，而类负责组合和迭代逻辑。
Cycler：
https://matplotlib.org/cycler/generated/cycler.Cycler.html#cycler.Cycler
循环器（Cycler）用法
基础（Base）
可以使用单个条目Cycler对象轻松地在单个样式上循环。要创建Cycler，请使用cycler()函数，它将key(键)/style(样式)/kwarg(关键字参数)链接到一系列值。key必须是可散列的（因为它最终将用作dict中的键(key)）。
·
·
·
·
·
·
·
·
·
·
ipython
In [1]: from __future__ import print_function
In [2]: from cycler import cycler
In [3]: color_cycle = cycler(color=['r', 'g', 'b'])
In [4]: color_cycleOut[4]: cycler('color', ['r', 'g', 'b'])
Cycler知道它的长度和键（一个集合set）：
·
·
·
·
·
In [5]: len(color_cycle)Out[5]: 3
In [6]: color_cycle.keysOut[6]: {'color'}
在该对象上迭代将产生一系列以标签（Cycler的keys）为键的dict对象：
·
·
·
·
·
·
In [7]: for v in color_cycle: ...: print(v) ...:{'color': 'r'}{'color': 'g'}{'color': 'b'}
Cycler对象可以作为参数传递给cycler()，后者返回一个带有新标签但值相同的新Cycler。
·
·
In [8]: cycler(ec=color_cycle)Out[8]: cycler('ec', ['r', 'g', 'b'])
在Cycler上迭代会导致有限的条目列表，要获得无限循环，请调用Cycler对象（a-la生成器）
·
·
·
·
·
·
·
·
·
·
In [9]: cc = color_cycle()
In [10]: for j, c in zip(range(5), cc): ...: print(j, c) ...:0 {'color': 'r'}1 {'color': 'g'}2 {'color': 'b'}3 {'color': 'r'}4 {'color': 'g'}
组合方式（Composition）
单个Cycler同样可以被单个for循环替换。Cycler对象的强大之处在于，它们可以组合起来，轻松创建复杂的多键循环。
加法（Addition）
具有不同键的等长Cycler可以相加，以获得两个循环的“内积”。
·
·
·
In [11]: lw_cycle = cycler(lw=range(1, 4))
In [12]: wc = lw_cycle + color_cycle
结果具有相同的长度，并且具有两个输入Cycler的键的并集的键。
·
·
·
·
·
In [13]: len(wc)Out[13]: 3
In [14]: wc.keysOut[14]: {'color', 'lw'}
对结果进行迭代是两个输入Cycler的zip（每一个项含有对应2个输入的键值对）。
·
·
·
·
·
·
In [15]: for s in wc: ...: print(s) ...:{'lw': 1, 'color': 'r'}{'lw': 2, 'color': 'g'}{'lw': 3, 'color': 'b'}
与算术一样，加法是可交换的。
·
·
·
·
·
·
·
·
·
·
In [16]: lw_c = lw_cycle + color_cycle
In [17]: c_lw = color_cycle + lw_cycle
In [18]: for j, (a, b) in enumerate(zip(lw_c, c_lw)): ...: print('({j}) A: {A!r} B: {B!r}'.format(j=j, A=a, B=b)) ...:(0) A: {'lw': 1, 'color': 'r'} B: {'color': 'r', 'lw': 1}(1) A: {'lw': 2, 'color': 'g'} B: {'color': 'g', 'lw': 2}(2) A: {'lw': 3, 'color': 'b'} B: {'color': 'b', 'lw': 3}
为了方便起见，cycler()函数可以有多个键值对，并通过相加将它们自动组合成一个Cycler。
·
·
·
·
·
·
·
·
In [19]: wc = cycler(c=['r', 'g', 'b'], lw=range(3))
In [20]: for s in wc: ...: print(s) ...:{'c': 'r', 'lw': 0}{'c': 'g', 'lw': 1}{'c': 'b', 'lw': 2}
乘法（Multiplication）
任何一对Cycler都可以相乘。
·
·
·
In [21]: m_cycle = cycler(marker=['s', 'o'])
In [22]: m_c = m_cycle * color_cycle
它给出两个循环的“外积”（与itertools.product()相同）。
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
In [23]: len(m_c)Out[23]: 6
In [24]: m_c.keysOut[24]: {'color', 'marker'}
In [25]: for s in m_c: ...: print(s) ...:{'marker': 's', 'color': 'r'}{'marker': 's', 'color': 'g'}{'marker': 's', 'color': 'b'}{'marker': 'o', 'color': 'r'}{'marker': 'o', 'color': 'g'}{'marker': 'o', 'color': 'b'}
注意，与加法不同，乘法不可交换（如矩阵）。结果的项目集合虽然一样，但对应的项目可能不一样。
·
·
·
·
·
·
·
·
·
·
·
In [26]: c_m = color_cycle * m_cycle
In [27]: for j, (a, b) in enumerate(zip(c_m, m_c)): ...: print('({j}) A: {A!r} B: {B!r}'.format(j=j, A=a, B=b)) ...:(0) A: {'color': 'r', 'marker': 's'} B: {'marker': 's', 'color': 'r'}(1) A: {'color': 'r', 'marker': 'o'} B: {'marker': 's', 'color': 'g'}(2) A: {'color': 'g', 'marker': 's'} B: {'marker': 's', 'color': 'b'}(3) A: {'color': 'g', 'marker': 'o'} B: {'marker': 'o', 'color': 'r'}(4) A: {'color': 'b', 'marker': 's'} B: {'marker': 'o', 'color': 'g'}(5) A: {'color': 'b', 'marker': 'o'} B: {'marker': 'o', 'color': 'b'}
整数相乘（Integer Multiplication）
Cycler也可以乘以整数值以增加长度。
·
·
·
·
·
In [28]: color_cycle * 2Out[28]: cycler('color', ['r', 'g', 'b', 'r', 'g', 'b'])
In [29]: 2 * color_cycleOut[29]: cycler('color', ['r', 'g', 'b', 'r', 'g', 'b'])
连接（Concatenation）
可以通过Cycler.concat()方法连接Cycler对象：
·
·
In [30]: color_cycle.concat(color_cycle)Out[30]: cycler('color', ['r', 'g', 'b', 'r', 'g', 'b'])
或顶级concat()函数：
·
·
·
·
In [31]: from cycler import concat
In [32]: concat(color_cycle, color_cycle)Out[32]: cycler('color', ['r', 'g', 'b', 'r', 'g', 'b'])
切片（Slicing）
可以使用slice（切片）对象切片循环。
·
·
·
·
·
·
·
·
In [33]: color_cycle[::-1]Out[33]: cycler('color', ['b', 'g', 'r'])
In [34]: color_cycle[:2]Out[34]: cycler('color', ['r', 'g'])
In [35]: color_cycle[1:]Out[35]: cycler('color', ['g', 'b'])
以返回循环的子集作为新的Cycler。
检查Cycler
要检查转置的Cycler的值，请使用Cycler.by_key方法：
·
·
·
·
In [36]: c_m.by_key()Out[36]:{'marker': ['s', 'o', 's', 'o', 's', 'o'], 'color': ['r', 'r', 'g', 'g', 'b', 'b']}
此dict可以被改变，并用于创建具有更新值的新Cycler。
·
·
·
·
·
·
In [37]: bk = c_m.by_key()
In [38]: bk['color'] = ['green'] * len(c_m)
In [39]: cycler(**bk)Out[39]: (cycler('marker', ['s', 'o', 's', 'o', 's', 'o']) + cycler('color', ['green', 'green', 'green', 'green', 'green', 'green']))
示例
我们可以使用Cycler实例在一个或多个kwarg上循环以绘制（plot）：
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
from cycler import cyclerfrom itertools import cycle
fig, (ax1, ax2) = plt.subplots(1, 2, tight_layout=True, figsize=(8, 4))x = np.arange(10)
color_cycle = cycler(c=['r', 'g', 'b'])
for i, sty in enumerate(color_cycle): ax1.plot(x, x*(i+1), **sty)
for i, sty in zip(range(1, 5), cycle(color_cycle)): ax2.plot(x, x*i, **sty)
完整代码：
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
ipython%matplotlib tkimport matplotlib.pyplot as pltimport numpy as npfrom cycler import cyclerfrom itertools import cycle
fig, (ax1, ax2) = plt.subplots(1, 2, tight_layout=True, figsize=(8, 4))x = np.arange(10)
color_cycle = cycler(c=['r', 'g', 'b'])
for i, sty in enumerate(color_cycle): ax1.plot(x, x*(i+1), **sty)
for i, sty in zip(range(1, 5), cycle(color_cycle)): ax2.plot(x, x*i, **sty)
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
from cycler import cyclerfrom itertools import cycle
fig, (ax1, ax2) = plt.subplots(1, 2, tight_layout=True, figsize=(8, 4))x = np.arange(10)
color_cycle = cycler(c=['r', 'g', 'b'])ls_cycle = cycler('ls', ['-', '--'])lw_cycle = cycler('lw', range(1, 4))
sty_cycle = ls_cycle * (color_cycle + lw_cycle)
for i, sty in enumerate(sty_cycle): ax1.plot(x, x*(i+1), **sty)
sty_cycle = (color_cycle + lw_cycle) * ls_cycle
for i, sty in enumerate(sty_cycle): ax2.plot(x, x*(i+1), **sty)
完整代码：
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
ipython%matplotlib tkimport matplotlib.pyplot as pltimport numpy as npfrom cycler import cyclerfrom itertools import cycle
fig, (ax1, ax2) = plt.subplots(1, 2, tight_layout=True, figsize=(8, 4))x = np.arange(10)
color_cycle = cycler(c=['r', 'g', 'b'])ls_cycle = cycler('ls', ['-', '--'])lw_cycle = cycler('lw', range(1, 4))
sty_cycle = ls_cycle * (color_cycle + lw_cycle)
for i, sty in enumerate(sty_cycle): ax1.plot(x, x*(i+1), **sty)
sty_cycle = (color_cycle + lw_cycle) * ls_cycle
for i, sty in enumerate(sty_cycle): ax2.plot(x, x*(i+1), **sty)
持续性循环
通过字典查找将给定标签与样式相关联，并动态生成该映射可能很有用。这可以使用defaultdict轻松完成。
·
·
·
·
·
In [40]: from cycler import cycler as cy
In [41]: from collections import defaultdict
In [42]: cyl = cy('c', 'rgb') + cy('lw', range(1, 4))
获取有限的样式集。
·
·
·
In [43]: finite_cy_iter = iter(cyl)
In [44]: dd_finite = defaultdict(lambda : next(finite_cy_iter))
或重复
·
·
·
In [45]: loop_cy_iter = cyl()
In [46]: dd_loop = defaultdict(lambda : next(loop_cy_iter))
这在绘制既有分类又有标签的复杂数据时非常有用。
·
·
·
·
finite_cy_iter = iter(cyl)styles = defaultdict(lambda : next(finite_cy_iter))for group, label, data in DataSet: ax.plot(data, label=label, **styles[group])
这将导致具有相同组的每个数据以相同样式绘制。
异常
如果将不等长度的Cycler相加，则会引发ValueError。
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
In [47]: cycler(c=['r', 'g', 'b']) + cycler(ls=['-', '--'])---------------------------------------------------------------------------ValueError Traceback (most recent call last)Cell In[47], line 1----> 1 cycler(c=['r', 'g', 'b']) + cycler(ls=['-', '--'])
File D:\5xstar\Python\Lib\site-packages\cycler.py:259, in Cycler.__add__(self, other) 251 """ 252 Pair-wise combine two equal length cyclers (zip). 253 (...) 256 other : Cycler 257 """ 258 if len(self) != len(other):--> 259 raise ValueError("Can only add equal length cycles, " 260 f"not {len(self)} and {len(other)}") 261 return Cycler(self, other, zip)
ValueError: Can only add equal length cycles, not 3 and 2
或者如果组成了具有重叠键的两个循环。
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
In [48]: color_cycle = cycler(c=['r', 'g', 'b'])
In [49]: color_cycle + color_cycle---------------------------------------------------------------------------ValueError Traceback (most recent call last)Cell In[49], line 1----> 1 color_cycle + color_cycle
File D:\5xstar\Python\Lib\site-packages\cycler.py:261, in Cycler.__add__(self, other) 258 if len(self) != len(other): 259 raise ValueError("Can only add equal length cycles, " 260 f"not {len(self)} and {len(other)}")--> 261 return Cycler(self, other, zip)
File D:\5xstar\Python\Lib\site-packages\cycler.py:159, in Cycler.__init__(self, left, right, op) 156 else: 157 self._right = None--> 159 self._keys = _process_keys(self._left, self._right) 160 self._op = op
File D:\5xstar\Python\Lib\site-packages\cycler.py:71, in _process_keys(left, right) 69 r_key = set(r_peek.keys()) 70 if l_key & r_key:---> 71 raise ValueError("Can not compose overlapping cycles") 72 return l_key | r_key
ValueError: Can not compose overlapping cycles
动机（Motivation）
当绘制多条线时，通常希望能够在一个或多个艺术家样式之间循环。对于不需要太多麻烦就能完成的简单情况：
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
fig, ax = plt.subplots(tight_layout=True)x = np.linspace(0, 2*np.pi, 1024)
for i, (lw, c) in enumerate(zip(range(4), ['r', 'g', 'b', 'k'])): ax.plot(x, np.sin(x - i * np.pi / 4), label=r'$\phi = {{{0}}} \pi / 4$'.format(i), lw=lw + 1, c=c)
ax.set_xlim([0, 2*np.pi])ax.set_title(r'$y=\sin(\theta + \phi)$')ax.set_ylabel(r'[arb]')ax.set_xlabel(r'$\theta$ [rad]')
ax.legend(loc=0)
完整代码：
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
ipython%matplotlib tkimport matplotlib.pyplot as pltimport numpy as npfig, ax = plt.subplots(tight_layout=True)x = np.linspace(0, 2*np.pi, 1024)
for i, (lw, c) in enumerate(zip(range(4), ['r', 'g', 'b', 'k'])): ax.plot(x, np.sin(x - i * np.pi / 4), label=r'$\phi = {{{0}}} \pi / 4$'.format(i), lw=lw + 1, c=c)
ax.set_xlim([0, 2*np.pi])ax.set_title(r'$y=\sin(\theta + \phi)$')ax.set_ylabel(r'[arb]')ax.set_xlabel(r'$\theta$ [rad]')
ax.legend(loc=0)
再者，做复杂一些的事情：
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
fig, ax = plt.subplots(tight_layout=True)x = np.linspace(0, 2*np.pi, 1024)
for i, (lw, c) in enumerate(zip(range(4), ['r', 'g', 'b', 'k'])): if i % 2: ls = '-' else: ls = '--' ax.plot(x, np.sin(x - i * np.pi / 4), label=r'$\phi = {{{0}}} \pi / 4$'.format(i), lw=lw + 1, c=c, ls=ls)
ax.set_xlim([0, 2*np.pi])ax.set_title(r'$y=\sin(\theta + \phi)$')ax.set_ylabel(r'[arb]')ax.set_xlabel(r'$\theta$ [rad]')
ax.legend(loc=0)
完整代码：
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
ipython%matplotlib tkimport matplotlib.pyplot as pltimport numpy as npfig, ax = plt.subplots(tight_layout=True)x = np.linspace(0, 2*np.pi, 1024)
for i, (lw, c) in enumerate(zip(range(4), ['r', 'g', 'b', 'k'])): if i % 2: ls = '-' else: ls = '--' ax.plot(x, np.sin(x - i * np.pi / 4), label=r'$\phi = {{{0}}} \pi / 4$'.format(i), lw=lw + 1, c=c, ls=ls)
ax.set_xlim([0, 2*np.pi])ax.set_title(r'$y=\sin(\theta + \phi)$')ax.set_ylabel(r'[arb]')ax.set_xlabel(r'$\theta$ [rad]')
ax.legend(loc=0)
然而，绘图逻辑可以变得非常复杂，上面简单的循环方法已无法解决参数问题。为了解决这一问题，并允许在任意关键字参数（kwargs）上轻松循环，开发了Cycler类，这是一个可组合的关键字参数（kwargs）迭代器。
文中链接
cycler()：
https://matplotlib.org/cycler/generated/cycler.cycler.html#cycler.cycler
Cycler：
https://matplotlib.org/cycler/generated/cycler.Cycler.html#cycler.Cycler
concat()：
https://matplotlib.org/cycler/generated/cycler.concat.html#cycler.concat
itertools.chain：
https://docs.python.org/3/library/itertools.html#itertools.chain
dict：
https://docs.python.org/3/library/stdtypes.html#dict
itertools.product()：
https://docs.python.org/3/library/itertools.html#itertools.product
Cycler.concat()：
https://matplotlib.org/cycler/generated/cycler.Cycler.html#cycler.Cycler.concat
slice：
https://docs.python.org/3/library/functions.html#slice
Cycler.by_key：
https://matplotlib.org/cycler/generated/cycler.Cycler.html#cycler.Cycler.by_key
plot：
https://matplotlib.org/api/_as_gen/matplotlib.axes.Axes.plot.html#matplotlib.axes.Axes.plot
defaultdict：
https://docs.python.org/3/library/collections.html#collections.defaultdict
ValueError：
https://docs.python.org/3/library/exceptions.html#ValueError