精华内容
下载资源
问答
  • Annotate (aka AnnotateModels) Add a comment summarizing the current schema to the top or bottom of each of your... ActiveRecord models Fixture files Tests and Specs Object Daddy exemplars ...
  • Django annotate

    千次阅读 2019-05-13 00:26:40
    今天才懂了一点ORM中的聚合函数annotate()在处理两张表时是如何操作的: annotate()就是先将两表一般是左外连接,如: A.objects.all().annotate(xxx='Count(b__id)') 在这句中,annotate首先将A表中各记录的id拿去...

    今天才懂了一点ORM中的聚合函数annotate()在处理两张表时是如何操作的:

    annotate()就是先将两表一般是左外连接,如: A.objects.all().annotate(xxx='Count(b__id)')   在这句中,annotate首先将A表中各记录的id拿去与B表中的记录的A外键的id比较也就是A左外连接B,默认相同属性值是id。  然后由数据库的知识可以了解到,要使用聚合函数Sum、Count之类的就得先分组,如果不分组那就是对整体这一个大的组进行操作。这里annotate()在左外连接两个表之后,默认会以A的主码进行分组group by 然后对分组后的进行聚集函数操作。

     

    res=models.Cls.objects.all().annotate(num=Count('student__id'))
    
    在这个关系中,班级与学生是一对多的关系,学生表中保留有班级的id
    
    查询班级中的人数
    

     

    展开全文
  • DBIx::Schema::Annotate - 添加表模式作为对 ORM 文件的注释。 这个模块的灵感来自 annotate_models。 概要 use DBIx::Schema::Annotate; my $dbh = DBI->connect('....') or die $DBI::errstr; my $annotate = ...
  • fis-postprocessor-annotate add ng-annotate for angularjs in fis postprocessor 在fis里继承ng-annotate的功能 安装 npm install -g fis-postprocessor-annotate 然后再fis-conf.js中开始annotate插件(如果基于...
  • 狼吞虎咽注释 使用 ngAnnotate 将 Angular 代码转换为缩小安全的注释格式。 安装 如果您还没有安装 gobble 安装。...选项与通常与 ng-annotate 一起使用的选项相同,除了默认情况下源映射处于活动状态并且“添加”模式
  • Annotate-crx插件

    2021-04-04 18:51:52
    annotate! 一个延期意味着帮助您使用您想要的信息和轻松的信息向您的网页注释。 非常适合学生,研究人员,Web开发人员,网页设计师,网络辅助功能等等! 用户能够通过放置引脚,突出显示页面,写文本,戳文本和...
  • Matplotlib中annotate详解

    万次阅读 多人点赞 2018-04-14 13:30:27
    ... 文本的一个常见用例是标注绘图的某些特征,而annotate()方法提供辅助函数,使标注变得容易。 在标注中,有两个要考虑的点:由参数xy表示的标注位置和xytext的文本位置。 这两个参数都是(x,...

    原文:https://blog.csdn.net/wizardforcel/article/details/54782628

    标注

     

    基本标注

    使用text()会将文本放置在轴域的任意位置。 文本的一个常见用例是标注绘图的某些特征,而annotate()方法提供辅助函数,使标注变得容易。 在标注中,有两个要考虑的点:由参数xy表示的标注位置和xytext的文本位置。 这两个参数都是(x, y)元组。

     

    # coding=utf-8
    
    
    import numpy as np
    import matplotlib.pyplot as plt
    
    
    
    fig = plt.figure()
    
    ax = fig.add_subplot(111)
    
    x = np.arange(0.0, 5.0, 0.01)
    y = np.cos(2*np.pi*x)
    ax.plot(x, y, lw = 2)
    
    '''
        xy=(横坐标,纵坐标)  箭头尖端
        xytext=(横坐标,纵坐标) 文字的坐标,指的是最左边的坐标
        arrowprops= {
            facecolor= '颜色',
            shrink = '数字' <1  收缩箭头
        }
    
    '''
    
    ax.annotate('local max', xy=(2,1), xytext=(3,1.5),
                arrowprops=dict(facecolor='black', shrink=0.05)) #
    
    ax.set_ylim(-2, 2) #设置y轴刻度的范围
    
    plt.show()

     

    # coding=utf-8
    
    
    import numpy as np
    import matplotlib.pyplot as plt
    
    
    
    fig = plt.figure()
    
    ax = fig.add_subplot(111)
    
    x = np.arange(0.0, 5.0, 0.01)
    y = np.cos(2*np.pi*x)
    ax.plot(x, y, lw = 2)
    
    '''
        xy=(横坐标,纵坐标)  箭头尖端
        xytext=(横坐标,纵坐标) 文字的坐标,指的是最左边的坐标
        arrowprops= {
            facecolor= '颜色',
            shrink = '数字' <1  收缩箭头
        }
    
    '''
     
    ax.annotate('local max', xy=(3, 1),  xycoords='data',
                xytext=(0.8, 0.95), textcoords='axes fraction',
                arrowprops=dict(facecolor='black', shrink=0.05),
                horizontalalignment='right', verticalalignment='top',fontsize=10
                #horizontalalignment,verticalalignment和fontsize,从annotate传给Text(local max)
                )
    ax.set_ylim(-2, 2) #设置y轴刻度的范围
    
    plt.show()
    

     

     

    在该示例中,xy(箭头尖端)和xytext位置(文本位置)都以数据坐标为单位。 有多种可以选择的其他坐标系 - 你可以使用xycoordstextcoords以及下列字符串之一(默认为data)指定xyxytext的坐标系。

    | 参数 | 坐标系 | 
    'figure points' | 距离图形左下角的点数量 | 
    'figure pixels' | 距离图形左下角的像素数量 | 
    'figure fraction' | 0,0 是图形左下角,1,1 是右上角 | 
    'axes points' | 距离轴域左下角的点数量 | 
    'axes pixels' | 距离轴域左下角的像素数量 | 
    'axes fraction' | 0,0 是轴域左下角,1,1 是右上角 | 
    'data' | 使用轴域数据坐标系 |

     

    你可以通过在可选关键字参数arrowprops中提供箭头属性字典来绘制从文本到注释点的箭头。

    arrowprops描述
    width箭头宽度,以点为单位
    frac箭头头部所占据的比例
    headwidth箭头的底部的宽度,以点为单位
    shrink移动提示,并使其离注释点和文本一些距离
    **kwargsmatplotlib.patches.Polygon的任何键,例如facecolor

    在下面的示例中,xy点是原始坐标(xycoords默认为'data')。 对于极坐标轴,它在(theta, radius)空间中。 此示例中的文本放置在图形小数坐标系中。 matplotlib.text.Text关键字args,例如horizontalalignmentverticalalignmentfontsize,从annotate传给Text实例。

    # coding=utf-8
    
    
    import numpy as np
    import matplotlib.pyplot as plt
    
    fig = plt.figure()
    ax = fig.add_subplot(111, polar=True)
    r = np.arange(0,1,0.001)
    theta = 2*2*np.pi*r
    line, = ax.plot(theta, r, color='#ee8d18', lw=3)
    
    ind = 800
    thisr, thistheta = r[ind], theta[ind]
    ax.plot([thistheta], [thisr], 'o')
    ax.annotate('a polar annotation',
                xy=(thistheta, thisr),  # theta, radius
                xytext=(0.05, 0.05),    # fraction, fraction
                textcoords='figure fraction',
                #| 'figure fraction' | 0,0 是图形左下角,1,1 是右上角 |
                arrowprops=dict(facecolor='black', shrink=0.05),
                horizontalalignment='left',
                verticalalignment='bottom',
                )
    plt.show()
    

     

     

     

     

    高级标注

    使用框和文本来标注

    让我们以一个简单的例子来开始。

     

    # coding=utf-8
    
    import numpy.random
    import matplotlib.pyplot as plt
    
    fig = plt.figure(1, figsize=(5,5))
    fig.clf()
    
    ax = fig.add_subplot(111)
    ax.set_aspect(1)
    
    x1 = -1 + numpy.random.randn(100)
    y1 = -1 + numpy.random.randn(100)
    x2 = 1. + numpy.random.randn(100)
    y2 = 1. + numpy.random.randn(100)
    
    ax.scatter(x1, y1, color="r")
    ax.scatter(x2, y2, color="g")
    
    bbox_props = dict(boxstyle="round", fc="w", ec="0.5", alpha=0.9)
    
    
    '''
        以文本坐标(-2,-2)
        ha="center"  在水平方向上,方框的中心在为(-2,0)
        va="center"  在垂直方向上,方框的中心在为(0,-2)
        size = '20' 代表方框的大小
        bbox={}  代表对方框的设置
            { 
                boxstyle= '' 代表边框的类型
                        round 圆形方框
                        rarrow箭头
                fc  背景颜色   英文首字母 w -whiite r-red
                ec 边框线的透明度  数字或颜色的首字母
                alpha 字体的透明度
                lw 线的粗细
                rotation  角度
            }
    '''
    
    ax.text(-2, -2, "Sample A", ha="center", va="center", size=20,
            bbox=bbox_props)
    
    ax.text(2, 2, "Sample B", ha="center", va="center", size=20,
            bbox=bbox_props)
    
    
    bbox_props = dict(boxstyle="rarrow", fc=(0.8,0.9,0.9), ec="b", lw=2)
    t = ax.text(0, 0, "Direction", ha="center", va="center", rotation=45,
                size=15,
                bbox=bbox_props)
    
    bb = t.get_bbox_patch()
    bb.set_boxstyle("rarrow", pad=0.6)
    
    ax.set_xlim(-4, 4)
    ax.set_ylim(-4, 4)
    
    plt.draw()
    plt.show()
    

     

     

     

    pyplot模块(或Axes类的text方法)中的text()函数接受bbox关键字参数,并且在提供时,在文本周围绘制一个框。

    与文本相关联的补丁对象可以通过以下方式访问:

    bb = t.get_bbox_patch()
    • 1

    返回值是FancyBboxPatch的一个实例,并且补丁属性(如facecoloredgewidth等)可以像平常一样访问和修改。 为了更改框的形状,请使用set_boxstyle方法。

    bb.set_boxstyle("rarrow", pad=0.6)
    • 1

    该参数是框样式的名称与其作为关键字参数的属性。 目前,实现了以下框样式。

    名称属性
    Circlecirclepad=0.3
    DArrowdarrowpad=0.3
    LArrowlarrowpad=0.3
    RArrowrarrowpad=0.3
    Roundroundpad=0.3,rounding_size=None
    Round4round4pad=0.3,rounding_size=None
    Roundtoothroundtoothpad=0.3,tooth_size=None
    Sawtoothsawtoothpad=0.3,tooth_size=None
    Squaresquarepad=0.3
    # coding=utf-8
    import matplotlib.patches as mpatch
    import matplotlib.pyplot as plt
    
    styles = mpatch.BoxStyle.get_styles()#返回边框的集合
    spacing = 1.2
    
    figheight = (spacing * len(styles) + .5)
    fig1 = plt.figure(1, (4/1.5, figheight/1.5))
    fontsize = 0.3 * 72
    
    for i, stylename in enumerate(sorted(styles.keys())):
        print(i, stylename)
        fig1.text(0.5, (spacing * (float(len(styles)) - i) - 0.5)/figheight, stylename,
                  ha="center",
                  size=fontsize,
                  transform=fig1.transFigure,
                  bbox=dict(boxstyle=stylename, fc="w", ec="k"))
    plt.draw()
    plt.show()
    

     

    注意,属性参数可以在样式名称中用逗号分隔(在初始化文本实例时,此形式可以用作bbox参数的boxstyle的值)。

    bb.set_boxstyle("rarrow,pad=0.6")

    使用箭头来标注

    pyplot模块(或Axes类的annotate方法)中的annotate()函数用于绘制连接图上两点的箭头。

     

     

    ax.annotate("Annotation",
                xy=(x1, y1), xycoords='data',
                xytext=(x2, y2), textcoords='offset points',
                )
    • 1
    • 2
    • 3
    • 4

    这会使用textcoords中提供的,xytext处的文本标注提供坐标(xycoords)中的xy处的点。 通常,数据坐标中规定了标注点,偏移点中规定了标注文本。 请参阅annotate()了解可用的坐标系。

    连接两个点(xyxytext)的箭头可以通过指定arrowprops参数可选地绘制。 为了仅绘制箭头,请使用空字符串作为第一个参数。

    ax.annotate("",
                xy=(0.2, 0.2), xycoords='data',
                xytext=(0.8, 0.8), textcoords='data',
                arrowprops=dict(arrowstyle="->",
                                connectionstyle="arc3"),
                )
    import matplotlib.pyplot as plt
    
    plt.figure(1, figsize=(3,3))
    ax = plt.subplot(111)
    '''
        
    arrowprops = {
        arrowstyle 箭头类型
        connectionstyle:xy与xytext连接之间类型
    }
    '''
    ax.annotate("s",
                xy=(0.2, 0.2), xycoords='data',
                xytext=(0.8, 0.8), textcoords='data',
                arrowprops=dict(arrowstyle="->",
                                connectionstyle="arc3"),
                )
    
    plt.show()
    
    

     

    箭头的绘制需要几个步骤。

    • 创建两个点之间的连接路径。 这由connectionstyle键值控制。
    • 如果提供了补丁对象(patchApatchB),则会剪切路径以避开该补丁。
    • 路径进一步由提供的像素总量来缩小(shirnkA&shrinkB
    • 路径转换为箭头补丁,由arrowstyle键值控制。

     

     

     

    # coding=utf-8
    
    
    import matplotlib.pyplot as plt
    import matplotlib.patches as mpatches
    
    x1, y1 = 0.3, 0.3
    x2, y2 = 0.7, 0.7
    
    fig = plt.figure(1, figsize=(8,3))
    fig.clf()
    from mpl_toolkits.axes_grid.axes_grid import AxesGrid
    from mpl_toolkits.axes_grid.anchored_artists import AnchoredText
    
    #from matplotlib.font_manager import FontProperties
    
    def add_at(ax, t, loc=2):
        fp = dict(size=10)
        _at = AnchoredText(t, loc=loc, prop=fp)
        ax.add_artist(_at)
        return _at
    
    
    grid = AxesGrid(fig, 111, (1, 4), label_mode="1", share_all=True)
    
    grid[0].set_autoscale_on(False)
    
    ax = grid[0]
    ax.plot([x1, x2], [y1, y2], ".")
    el = mpatches.Ellipse((x1, y1), 0.3, 0.4, angle=30, alpha=0.2)
    ax.add_artist(el)
    ax.annotate("",
                xy=(x1, y1), xycoords='data',
                xytext=(x2, y2), textcoords='data',
                arrowprops=dict(arrowstyle="-", #linestyle="dashed",
                                color="0.5",
                                patchB=None,
                                shrinkB=0,
                                connectionstyle="arc3,rad=0.3",
                                ),
                )
    
    add_at(ax, "connect", loc=2)
    
    ax = grid[1]
    ax.plot([x1, x2], [y1, y2], ".")
    el = mpatches.Ellipse((x1, y1), 0.3, 0.4, angle=30, alpha=0.2)
    ax.add_artist(el)
    ax.annotate("",
                xy=(x1, y1), xycoords='data',
                xytext=(x2, y2), textcoords='data',
                arrowprops=dict(arrowstyle="-", #linestyle="dashed",
                                color="0.5",
                                patchB=el,
                                shrinkB=0,
                                connectionstyle="arc3,rad=0.3",
                                ),
                )
    
    add_at(ax, "clip", loc=2)
    
    
    ax = grid[2]
    ax.plot([x1, x2], [y1, y2], ".")
    el = mpatches.Ellipse((x1, y1), 0.3, 0.4, angle=30, alpha=0.2)
    ax.add_artist(el)
    ax.annotate("",
                xy=(x1, y1), xycoords='data',
                xytext=(x2, y2), textcoords='data',
                arrowprops=dict(arrowstyle="-", #linestyle="dashed",
                                color="0.5",
                                patchB=el,
                                shrinkB=5,
                                connectionstyle="arc3,rad=0.3",
                                ),
                )
    
    add_at(ax, "shrink", loc=2)
    
    
    ax = grid[3]
    ax.plot([x1, x2], [y1, y2], ".")
    el = mpatches.Ellipse((x1, y1), 0.3, 0.4, angle=30, alpha=0.2)
    ax.add_artist(el)
    ax.annotate("",
                xy=(x1, y1), xycoords='data',
                xytext=(x2, y2), textcoords='data',
                arrowprops=dict(arrowstyle="fancy", #linestyle="dashed",
                                color="0.5",
                                patchB=el,
                                shrinkB=5,
                                connectionstyle="arc3,rad=0.3",
                                ),
                )
    
    add_at(ax, "mutate", loc=2)
    
    grid[0].set_xlim(0, 1)
    grid[0].set_ylim(0, 1)
    grid[0].axis["bottom"].toggle(ticklabels=False)
    grid[0].axis["left"].toggle(ticklabels=False)
    fig.subplots_adjust(left=0.05, right=0.95, bottom=0.05, top=0.95)
    
    plt.draw()
    plt.show()

     

    两个点之间的连接路径的创建由connectionstyle键控制,并且可用以下样式。

    名称属性
    angleangleA=90,angleB=0,rad=0.0
    angle3angleA=90,angleB=0
    arcangleA=0,angleB=0,armA=None,armB=None,rad=0.0
    arc3rad=0.0
    bararmA=0.0,armB=0.0,fraction=0.3,angle=None

    注意,angle3arc3中的3意味着所得到的路径是二次样条段(三个控制点)。 如下面将讨论的,当连接路径是二次样条时,可以使用一些箭头样式选项。

    每个连接样式的行为在下面的示例中(有限地)演示。 (警告:条形样式的行为当前未定义好,将来可能会更改)。

    源代码

    然后根据给定的箭头样式将连接路径(在剪切和收缩之后)变换为箭头补丁。

    名称属性
    -None
    ->head_length=0.4,head_width=0.2
    -[widthB=1.0,lengthB=0.2,angleB=None
    |-|widthA=1.0,widthB=1.0
    -|>head_length=0.4,head_width=0.2
    <-head_length=0.4,head_width=0.2
    <->head_length=0.4,head_width=0.2
    <|-head_length=0.4,head_width=0.2
    <-|>
    fancyhead_length=0.4,head_width=0.4,tail_width=0.4
    simplehead_length=0.5,head_width=0.5,tail_width=0.2
    wedgetail_width=0.3,shrink_factor=0.5

    源代码

    一些箭头仅适用于生成二次样条线段的连接样式。 他们是fancysimplewedge。 对于这些箭头样式,必须使用angle3arc3连接样式。

    如果提供了标注字符串,则patchA默认设置为文本的bbox补丁。

    源代码

    text命令一样,可以使用bbox参数来绘制文本周围的框。

    源代码

    默认情况下,起点设置为文本范围的中心。 可以使用relpos键值进行调整。 这些值根据文本的范围进行归一化。 例如,(0,0)表示左下角,(1,1)表示右上角。

    源代码

    将艺术家放置在轴域的锚定位置

    有一类艺术家可以放置在轴域的锚定位置。 一个常见的例子是图例。 这种类型的艺术家可以使用OffsetBox类创建。 mpl_toolkits.axes_grid.anchored_artists中有几个预定义类。

    from mpl_toolkits.axes_grid.anchored_artists import AnchoredText
    at = AnchoredText("Figure 1a",
                      prop=dict(size=8), frameon=True,
                      loc=2,
                      )
    at.patch.set_boxstyle("round,pad=0.,rounding_size=0.2")
    ax.add_artist(at)
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    源代码

    loc关键字与legend命令中含义相同。

    一个简单的应用是当艺术家(或艺术家的集合)的像素大小在创建时已知。 例如,如果要绘制一个固定大小为 20 像素 ×20 像素(半径为 10 像素)的圆,则可以使用AnchoredDrawingArea。 实例使用绘图区域的大小创建(以像素为单位)。 用户可以在绘图区任意添加艺术家。 注意,添加到绘图区域的艺术家的范围与绘制区域本身的位置无关,只和初始大小有关。

    from mpl_toolkits.axes_grid.anchored_artists import AnchoredDrawingArea
    
    ada = AnchoredDrawingArea(20, 20, 0, 0,
                              loc=1, pad=0., frameon=False)
    p1 = Circle((10, 10), 10)
    ada.drawing_area.add_artist(p1)
    p2 = Circle((30, 10), 5, fc="r")
    ada.drawing_area.add_artist(p2)
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    添加到绘图区域的艺术家不应该具有变换集(它们将被重写),并且那些艺术家的尺寸被解释为像素坐标,即,上述示例中的圆的半径分别是 10 像素和 5 像素。

    源代码

    有时,你想让你的艺术家按数据坐标(或其他坐标,而不是画布像素)缩放。 你可以使用AnchoredAuxTransformBox类。 这类似于AnchoredDrawingArea,除了艺术家的范围在绘制时由指定的变换确定。

    from mpl_toolkits.axes_grid.anchored_artists import AnchoredAuxTransformBox
    
    box = AnchoredAuxTransformBox(ax.transData, loc=2)
    el = Ellipse((0,0), width=0.1, height=0.4, angle=30) # in data coordinates!
    box.drawing_area.add_artist(el)
    • 1
    • 2
    • 3
    • 4
    • 5

    上述示例中的椭圆具有在数据坐标中对应于 0.1 和 0.4 的宽度和高度,并且当轴域的视图限制改变时将自动缩放。

    源代码

    如图例所示,可以设置bbox_to_anchor参数。 使用HPackerVPacker,你可以像图例中一样排列艺术家(事实上,这是图例的创建方式)。

    源代码

    请注意,与图例不同,默认情况下,bbox_transform设置为IdentityTransform

    使用复杂坐标来标注

    matplotlib 中的标注支持标注文本中描述的几种类型的坐标。 对于想要更多控制的高级用户,它支持几个其他选项。

    1. Transform实例,例如:

      ax.annotate("Test", xy=(0.5, 0.5), xycoords=ax.transAxes)
      • 1

      相当于:

      ax.annotate("Test", xy=(0.5, 0.5), xycoords="axes fraction")
      • 1

      使用它,你可以在其他轴域内标注一个点:

      ax1, ax2 = subplot(121), subplot(122)
      ax2.annotate("Test", xy=(0.5, 0.5), xycoords=ax1.transData,
                   xytext=(0.5, 0.5), textcoords=ax2.transData,
                   arrowprops=dict(arrowstyle="->"))
      • 1
      • 2
      • 3
      • 4
    2. Artist实例。xy值(或xytext)被解释为艺术家的bboxget_window_extent的返回值)的小数坐标。

      an1 = ax.annotate("Test 1", xy=(0.5, 0.5), xycoords="data",
                        va="center", ha="center",
                        bbox=dict(boxstyle="round", fc="w"))
      an2 = ax.annotate("Test 2", xy=(1, 0.5), xycoords=an1, # (1,0.5) of the an1's bbox
                        xytext=(30,0), textcoords="offset points",
                        va="center", ha="left",
                        bbox=dict(boxstyle="round", fc="w"),
                        arrowprops=dict(arrowstyle="->"))
      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8

      源代码

      请注意,你的责任是在绘制an2之前确定坐标艺术家(上例中的an1)的范围。 在大多数情况下,这意味着an2需要晚于an1

    3. 一个返回BboxBaseTransform的实例的可调用对象。 如果返回一个变换,它与 1 相同,如果返回bbox,它与 2 相同。可调用对象应该接受renderer实例的单个参数。 例如,以下两个命令产生相同的结果:

      an2 = ax.annotate("Test 2", xy=(1, 0.5), xycoords=an1,
                        xytext=(30,0), textcoords="offset points")
      an2 = ax.annotate("Test 2", xy=(1, 0.5), xycoords=an1.get_window_extent,
                        xytext=(30,0), textcoords="offset points")
      • 1
      • 2
      • 3
      • 4
    4. 指定二元坐标的元组。 第一项用于x坐标,第二项用于y坐标。 例如,

      annotate("Test", xy=(0.5, 1), xycoords=("data", "axes fraction"))
      • 1

      0.5 的单位是数据坐标,1 的单位是归一化轴域坐标。 你可以像使用元组一样使用艺术家或变换。 例如,

      import matplotlib.pyplot as plt
      
      plt.figure(figsize=(3,2))
      ax=plt.axes([0.1, 0.1, 0.8, 0.7])
      an1 = ax.annotate("Test 1", xy=(0.5, 0.5), xycoords="data",
                        va="center", ha="center",
                        bbox=dict(boxstyle="round", fc="w"))
      
      an2 = ax.annotate("Test 2", xy=(0.5, 1.), xycoords=an1,
                        xytext=(0.5,1.1), textcoords=(an1, "axes fraction"),
                        va="bottom", ha="center",
                        bbox=dict(boxstyle="round", fc="w"),
                        arrowprops=dict(arrowstyle="->"))
      plt.show()
      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14

      源代码

    5. 有时,您希望您的注释带有一些“偏移点”,不是距离注释点,而是距离某些其他点。 OffsetFrom是这种情况下的辅助类。

      import matplotlib.pyplot as plt
      
      plt.figure(figsize=(3,2))
      ax=plt.axes([0.1, 0.1, 0.8, 0.7])
      an1 = ax.annotate("Test 1", xy=(0.5, 0.5), xycoords="data",
                        va="center", ha="center",
                        bbox=dict(boxstyle="round", fc="w"))
      
      from matplotlib.text import OffsetFrom
      offset_from = OffsetFrom(an1, (0.5, 0))
      an2 = ax.annotate("Test 2", xy=(0.1, 0.1), xycoords="data",
                        xytext=(0, -10), textcoords=offset_from,
                        # xytext is offset points from "xy=(0.5, 0), xycoords=an1"
                        va="top", ha="center",
                        bbox=dict(boxstyle="round", fc="w"),
                        arrowprops=dict(arrowstyle="->"))
      plt.show()
      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17

      你可以参考这个链接:pylab_examples example code: annotation_demo3.py.

    使用ConnectorPatch

    ConnectorPatch类似于没有文本的标注。 虽然在大多数情况下建议使用标注函数,但是当您想在不同的轴上连接点时,ConnectorPatch很有用。

    from matplotlib.patches import ConnectionPatch
    xy = (0.2, 0.2)
    con = ConnectionPatch(xyA=xy, xyB=xy, coordsA="data", coordsB="data",
                          axesA=ax1, axesB=ax2)
    ax2.add_artist(con)
    • 1
    • 2
    • 3
    • 4
    • 5

    上述代码连接了ax1中数据坐标的xy点,与ax2中数据坐标的xy点。这是个简单的例子。

    源代码

    虽然ConnectorPatch实例可以添加到任何轴,但您可能需要将其添加到绘图顺序中最新的轴,以防止与其他轴重叠。

    高级话题

    轴域之间的缩放效果

    mpl_toolkits.axes_grid.inset_locator定义了一些补丁类,用于互连两个轴域。 理解代码需要一些 mpl 转换如何工作的知识。 但是,利用它的方式很直接。

    源代码

    定义自定义盒样式

    你可以使用自定义盒样式,boxstyle的值可以为如下形式的可调用对象:

    def __call__(self, x0, y0, width, height, mutation_size,
                 aspect_ratio=1.):
        """
        Given the location and size of the box, return the path of
        the box around it.
    
          - *x0*, *y0*, *width*, *height* : location and size of the box
          - *mutation_size* : a reference scale for the mutation.
          - *aspect_ratio* : aspect-ratio for the mutation.
        """
        path = ...
        return path
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    这里是个复杂的例子:

    源代码

    但是,推荐你从matplotlib.patches.BoxStyle._Base派生,像这样:

    from matplotlib.path import Path
    from matplotlib.patches import BoxStyle
    import matplotlib.pyplot as plt
    
    # we may derive from matplotlib.patches.BoxStyle._Base class.
    # You need to override transmute method in this case.
    
    class MyStyle(BoxStyle._Base):
        """
        A simple box.
        """
    
        def __init__(self, pad=0.3):
            """
            The arguments need to be floating numbers and need to have
            default values.
    
             *pad*
                amount of padding
            """
    
            self.pad = pad
            super(MyStyle, self).__init__()
    
        def transmute(self, x0, y0, width, height, mutation_size):
            """
            Given the location and size of the box, return the path of
            the box around it.
    
             - *x0*, *y0*, *width*, *height* : location and size of the box
             - *mutation_size* : a reference scale for the mutation.
    
            Often, the *mutation_size* is the font size of the text.
            You don't need to worry about the rotation as it is
            automatically taken care of.
            """
    
            # padding
            pad = mutation_size * self.pad
    
            # width and height with padding added.
            width, height = width + 2.*pad, \
                            height + 2.*pad,
    
            # boundary of the padded box
            x0, y0 = x0-pad, y0-pad,
            x1, y1 = x0+width, y0 + height
    
            cp = [(x0, y0),
                  (x1, y0), (x1, y1), (x0, y1),
                  (x0-pad, (y0+y1)/2.), (x0, y0),
                  (x0, y0)]
    
            com = [Path.MOVETO,
                   Path.LINETO, Path.LINETO, Path.LINETO,
                   Path.LINETO, Path.LINETO,
                   Path.CLOSEPOLY]
    
            path = Path(cp, com)
    
            return path
    
    
    # register the custom style
    BoxStyle._style_list["angled"] = MyStyle
    
    plt.figure(1, figsize=(3,3))
    ax = plt.subplot(111)
    ax.text(0.5, 0.5, "Test", size=30, va="center", ha="center", rotation=30,
            bbox=dict(boxstyle="angled,pad=0.5", alpha=0.2))
    
    del BoxStyle._style_list["angled"]
    
    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
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74

    源代码

    与之类似,您可以定义一个自定义的ConnectionStyle和一个自定义的ArrowStyle。 请参阅lib/matplotlib/patches.py的源代码,并查看每个样式类是如何定义的。

     

     

     

     

     

     

     

    展开全文
  • webpack 的加载器 用法 require ( 'ng-annotate!./file.js' ) ; 推荐配置 { module : { loaders : [ { test : / \. js $ / , loader : 'ng-annotate' } ] } } 执照 麻省理工学院( )
  • Annotate

    2019-09-27 07:13:23
    Annotate类中有个Annotator接口,定义如下: /** A client that has annotations to add registers an annotator, * the method it will use to add the annotation. There are no * parameters; any needed ...

     

    在Annotate类中有个Annotator接口,定义如下:

    /** A client that has annotations to add registers an annotator,
    *  the method it will use to add the annotation.  There are no
    *  parameters; any needed data should be captured by the
    *  Annotator.
    */
    public interface Annotator {
            void enterAnnotation();
            String toString();
    }
    

     

    其中的实现分部在MemberEnter与ClassReader类中,如下:

     

    方法1:

     /** Queue processing of an attribute default value. */
        void annotateDefaultValueLater(final JCExpression defaultValue,
                                        final Env<AttrContext> localEnv,
                                        final MethodSymbol m) {
            annotate.later(new Annotate.Annotator() {
                    public String toString() {
                        return "annotate " + m.owner + "." +  m + " default " + defaultValue;
                    }
                    public void enterAnnotation() {
                        JavaFileObject prev = log.useSource(localEnv.toplevel.sourcefile);
                        try {
                            enterDefaultValue(defaultValue, localEnv, m);
                        } finally {
                            log.useSource(prev);
                        }
                    }
                });
        }
    
        /** Enter a default value for an attribute method. */
        private void enterDefaultValue(final JCExpression defaultValue,
                                         final Env<AttrContext> localEnv,
                                         final MethodSymbol m) {
            m.defaultValue = annotate.enterAttributeValue(m.type.getReturnType(),defaultValue,localEnv);
        }
    

      

    方法2:

     /** Queue annotations for later processing. */
        void annotateLater(final List<JCAnnotation> annotations,
                           final Env<AttrContext> localEnv,
                           final Symbol s) {
            if (annotations.isEmpty()) {
                return;
            }
            if (s.kind != PCK) {
                s.attributes_field = null; // mark it incomplete for now
            }
            
            annotate.later(new Annotate.Annotator() {
                    public String toString() {
                        return "annotate " + annotations + " onto " + s + " in " + s.owner;
                    }
                    public void enterAnnotation() {
                        Assert.check(s.kind == PCK || s.attributes_field == null);
                        JavaFileObject prev = log.useSource(localEnv.toplevel.sourcefile);
                        try {
                            if (s.attributes_field != null &&
                                s.attributes_field.nonEmpty() &&
                                annotations.nonEmpty()) {
                                log.error(annotations.head.pos, "already.annotated", kindName(s), s);
                            }
                            enterAnnotations(annotations, localEnv, s);
                        } finally {
                            log.useSource(prev);
                        }
                    }
                });
        }
    

     

    其中调用了enterAnnotations()方法,代码如下:

     

     /** Enter a set of annotations. */
        private void enterAnnotations(List<JCAnnotation> annotations,Env<AttrContext> env,Symbol s) {
            ListBuffer<Attribute.Compound> buf =  new ListBuffer<Attribute.Compound>();
            Set<TypeSymbol> annotated = new HashSet<TypeSymbol>();
            if (!skipAnnotations) {
                for (List<JCAnnotation> al = annotations; al.nonEmpty(); al = al.tail) {
                    JCAnnotation a = al.head;
                    Attribute.Compound c = annotate.enterAnnotation(a, syms.annotationType, env);
                    if (c == null) {
                        continue;
                    }
                    buf.append(c);
                    // Note: @Deprecated has no effect on local variables and parameters
                    if (!c.type.isErroneous()
                            && s.owner.kind != MTH
                            && types.isSameType(c.type, syms.deprecatedType)) {
                        s.flags_field |= Flags.DEPRECATED;
                    }
                    // Internally to java.lang.invoke, a @PolymorphicSignature annotation
                    // acts like a classfile attribute.
                    if (!c.type.isErroneous() &&
                            types.isSameType(c.type, syms.polymorphicSignatureType)) {
                        if (!target.hasMethodHandles()) {
                            // Somebody is compiling JDK7 source code to a JDK6 target.
                            // Make it an error, since it is unlikely but important.
                            log.error(env.tree.pos(), "wrong.target.for.polymorphic.signature.definition", target.name);
                        }
                        // Pull the flag through for better diagnostics, even on a bad target.
                        s.flags_field |= Flags.POLYMORPHIC_SIGNATURE;
                    }
                    if (!annotated.add(a.type.tsym)) {
                        log.error(a.pos, "duplicate.annotation");
                    }
                }
            }
            s.attributes_field = buf.toList();
        }
    

     

      

     

     

     

    方法3:

    /** Import statics types of a given name.  Non-types are handled in Attr.
         *  @param pos           Position to be used for error reporting.
         *  @param tsym          The class from which the name is imported.
         *  @param name          The (simple) name being imported.
         *  @param env           The environment containing the named import
         *                  scope to add to.
         */
        private void importNamedStatic(final DiagnosticPosition pos,
                                         final TypeSymbol tsym,
                                         final Name name,
                                         final Env<AttrContext> env) {
            if (tsym.kind != TYP) {
                log.error(DiagnosticFlag.RECOVERABLE, pos, "static.imp.only.classes.and.interfaces");
                return;
            }
    
            final Scope toScope = env.toplevel.namedImportScope;
            final PackageSymbol packge = env.toplevel.packge;
            final TypeSymbol origin = tsym;
    
            // enter imported types immediately
            new Object() {
                Set<Symbol> processed = new HashSet<Symbol>();
                void importFrom(TypeSymbol tsym) {
                    if (tsym == null || !processed.add(tsym)) {
                        return;
                    }
    
                    // also import inherited names
                    importFrom(types.supertype(tsym.type).tsym);
                    for (Type t : types.interfaces(tsym.type)) {
                        importFrom(t.tsym);
                    }
    
                    for (Scope.Entry e = tsym.members().lookup(name); e.scope != null; e = e.next()) {
                        Symbol sym = e.sym;
                        if (sym.isStatic() &&
                            sym.kind == TYP &&
                            staticImportAccessible(sym, packge) &&
                            sym.isMemberOf(origin, types) &&
                            chk.checkUniqueStaticImport(pos, sym, toScope)) {
                            toScope.enter(sym, sym.owner.members(), origin.members());
                        }
                    }
                }
            }.importFrom(tsym);
    
            // enter non-types before annotations that might use them
            annotate.earlier(new Annotate.Annotator() {
                Set<Symbol> processed = new HashSet<Symbol>();
                boolean found = false;
    
                public String toString() {
                    return "import static " + tsym + "." + name;
                }
                void importFrom(TypeSymbol tsym) {
                    if (tsym == null || !processed.add(tsym)) {
                        return;
                    }
    
                    // also import inherited names
                    importFrom(types.supertype(tsym.type).tsym);
                    for (Type t : types.interfaces(tsym.type))
                        importFrom(t.tsym);
    
                    for (Scope.Entry e = tsym.members().lookup(name);e.scope != null;e = e.next()) {
                        Symbol sym = e.sym;
                        if (sym.isStatic() &&
                            staticImportAccessible(sym, packge) &&
                            sym.isMemberOf(origin, types)) {
                            found = true;
                            if (sym.kind == MTH ||
                                sym.kind != TYP && chk.checkUniqueStaticImport(pos, sym, toScope)) {
                                toScope.enter(sym, sym.owner.members(), origin.members());
                            }
                        }
                    }
                }
                public void enterAnnotation() {
                    JavaFileObject prev = log.useSource(env.toplevel.sourcefile);
                    try {
                        importFrom(tsym);
                        if (!found) {
                            log.error(pos, "cant.resolve.location",
                                      KindName.STATIC,
                                      name, List.<Type>nil(), List.<Type>nil(),
                                      Kinds.typeKindName(tsym.type),
                                      tsym.type);
                        }
                    } finally {
                        log.useSource(prev);
                    }
                }
            });
        }
    

      

    方法4:

     /** Import all static members of a class or package on demand.
         *  @param pos           Position to be used for error reporting.
         *  @param tsym          The class or package the members of which are imported.
         *  @param toScope   The (import) scope in which imported classes are entered.
         */
        private void importStaticAll(int pos,
                                     final TypeSymbol tsym,
                                     Env<AttrContext> env) {
            final JavaFileObject sourcefile = env.toplevel.sourcefile;
            final Scope toScope = env.toplevel.starImportScope;
            final PackageSymbol packge = env.toplevel.packge;
            final TypeSymbol origin = tsym;
    
            // enter imported types immediately
            new Object() {
                Set<Symbol> processed = new HashSet<Symbol>();
                void importFrom(TypeSymbol tsym) {
                    if (tsym == null || !processed.add(tsym)) {
                        return;
                    }
                    // also import inherited names
                    importFrom(types.supertype(tsym.type).tsym);
                    for (Type t : types.interfaces(tsym.type)) {
                        importFrom(t.tsym);
                    }
    
                    final Scope fromScope = tsym.members();
                    for (Scope.Entry e = fromScope.elems; e != null; e = e.sibling) {
                        Symbol sym = e.sym;
                        if (sym.kind == TYP &&
                            (sym.flags() & STATIC) != 0 &&
                            staticImportAccessible(sym, packge) &&
                            sym.isMemberOf(origin, types) &&
                            !toScope.includes(sym)
                        ){
                            toScope.enter(sym, fromScope, origin.members());
                        }
                    }
                }
            }.importFrom(tsym);
    
            // enter non-types before annotations that might use them
            annotate.earlier(new Annotate.Annotator() {
                Set<Symbol> processed = new HashSet<Symbol>();
    
                public String toString() {
                    return "import static " + tsym + ".*" + " in " + sourcefile;
                }
                void importFrom(TypeSymbol tsym) {
                    if (tsym == null || !processed.add(tsym)) {
                        return;
                    }
    
                    // also import inherited names
                    importFrom(types.supertype(tsym.type).tsym);
                    for (Type t : types.interfaces(tsym.type)) {
                        importFrom(t.tsym);
                    }
    
                    final Scope fromScope = tsym.members();
                    for (Scope.Entry e = fromScope.elems; e != null; e = e.sibling) {
                        Symbol sym = e.sym;
                        if (sym.isStatic() && sym.kind != TYP &&
                            staticImportAccessible(sym, packge) &&
                            !toScope.includes(sym) &&
                            sym.isMemberOf(origin, types)) {
                            toScope.enter(sym, fromScope, origin.members());
                        }
                    }
                }
                public void enterAnnotation() {
                    importFrom(tsym);
                }
            });
        }
    

      

      

     

    继承体系如下图:

      

     

     

     

    类1:

    class AnnotationCompleter extends AnnotationDeproxy implements Annotate.Annotator {
            final Symbol sym;
            final List<CompoundAnnotationProxy> l;
            final JavaFileObject classFile;
            @Override
            public String toString() {
                return " ClassReader annotate " + sym.owner + "." + sym + " with " + l;
            }
            AnnotationCompleter(Symbol sym, List<CompoundAnnotationProxy> l) {
                this.sym = sym;
                this.l = l;
                this.classFile = currentClassFile;
            }
            // implement Annotate.Annotator.enterAnnotation()
            public void enterAnnotation() {
                JavaFileObject previousClassFile = currentClassFile;
                try {
                    currentClassFile = classFile;
                    List<Attribute.Compound> newList = deproxyCompoundList(l);
                    sym.attributes_field = ((sym.attributes_field == null)
                                            ? newList
                                            : newList.prependList(sym.attributes_field));
                } finally {
                    currentClassFile = previousClassFile;
                }
            }
        }
    

      

    类2:

    class AnnotationDefaultCompleter extends AnnotationDeproxy implements Annotate.Annotator {
            final MethodSymbol sym;
            final Attribute value;
            final JavaFileObject classFile = currentClassFile;
            @Override
            public String toString() {
                return " ClassReader store default for " + sym.owner + "." + sym + " is " + value;
            }
            AnnotationDefaultCompleter(MethodSymbol sym, Attribute value) {
                this.sym = sym;
                this.value = value;
            }
            // implement Annotate.Annotator.enterAnnotation()
            public void enterAnnotation() {
                JavaFileObject previousClassFile = currentClassFile;
                try {
                    currentClassFile = classFile;
                    sym.defaultValue = deproxy(sym.type.getReturnType(), value);
                } finally {
                    currentClassFile = previousClassFile;
                }
            }
        }
    

      

     

     

     

     

     

     

     

     

     

     

     

      

    转载于:https://www.cnblogs.com/extjs4/p/8621398.html

    展开全文
  • annotate 和 aggregate

    2021-08-07 14:58:53
    annotate() 不是终端子句。annotate() 子句的输出就是 QuerySet 与aggregate方法不同的是,annotate方法返回结果的不仅仅是含有统计结果的一个字典,而是包含有新增统计字段的查询集(queryset) 假如Student和...

    aggregate() 是 QuerySet 的一个终端子句,使用后将返回“名称-值”的字典
    annotate() 不是终端子句。annotate() 子句的输出就是 QuerySet

    与aggregate方法不同的是,annotate方法返回结果的不仅仅是含有统计结果的一个字典,而是包含有新增统计字段的查询集(queryset)

    假如Student和Hobby是多对多
    # 按学生分组,统计每个学生的爱好数量

    Student.objects.annotate(Count('hobbies'))   

    # 按爱好分组,统计每个爱好的学生数量。

    Hobby.objects.annotate(Count('student'))

    又例如:

    annotate() 和 filter() 子句的顺序
    当开发一个涉及 annotate() 和 filter() 子句的复杂查询时,要特别注意应用于 QuerySet 的子句的顺序。

    当一个 annotate() 子句应用于查询,会根据查询状态来计算注解,直到请求的注解为止。这实际上意味着 filter() 和 annotate() 不是可交换的操作。

    比如:

    出版者A有两本评分4和5的书。
    出版者B有两本评分1和4的书。
    出版者C有一本评分1的书。
    下面就是 Count 聚合的例子:

    >>> a, b = Publisher.objects.annotate(num_books=Count('book', distinct=True)).filter(book__rating__gt=3.0)
    >>> a, a.num_books
    (<Publisher: A>, 2)
    >>> b, b.num_books
    (<Publisher: B>, 2)

    >>> a, b = Publisher.objects.filter(book__rating__gt=3.0).annotate(num_books=Count('book'))
    >>> a, a.num_books
    (<Publisher: A>, 2)
    >>> b, b.num_books
    (<Publisher: B>, 1)
    两个查询返回出版者列表,这些出版者至少有一本评分3的书,因此排除了C。

    在第一个查询里,注解优先于过滤器,因此过滤器没有影响注解。distinct=True 用来避免 a query bug。

    第二个查询每个发布者评分3以上的书籍数量。过滤器优先于注解,因此过滤器约束计算注解时考虑的对象。


    这里是另一个关于 Avg 聚合的例子:

    >>> a, b = Publisher.objects.annotate(avg_rating=Avg('book__rating')).filter(book__rating__gt=3.0)
    >>> a, a.avg_rating
    (<Publisher: A>, 4.5)  # (5+4)/2
    >>> b, b.avg_rating
    (<Publisher: B>, 2.5)  # (1+4)/2

    >>> a, b = Publisher.objects.filter(book__rating__gt=3.0).annotate(avg_rating=Avg('book__rating'))
    >>> a, a.avg_rating
    (<Publisher: A>, 4.5)  # (5+4)/2
    >>> b, b.avg_rating
    (<Publisher: B>, 4.0)  # 4/1 (book with rating 1 excluded)
    第一个查询请求至少有一本评分3以上的书籍的出版者的书籍平均分。第二个查询只请求评分3以上的作者书籍的平均评分。

    展开全文
  • ng-annotate-webpack-plugin 不建议使用ng-annotate。 考虑改用 。 在软件包中运行WebPack插件 基于 用法 在webpack.config.js中: var webpack = require ( 'webpack' ) ; var ngAnnotatePlugin = require ( 'ng...
  • Annotate介绍

    千次阅读 2017-01-16 00:45:13
    前言 在使用电脑的时候避免不了要截图,Mac上本身自带截图工具,可是只有两种功能,全屏截图/区域截图,但是当你想在截图后的图片上做标注时Mac自带工具就无能为力了。...Annotate还可以截取动态图,并且可以对动
  • rehype-annotate-源码

    2021-05-14 05:12:46
    rehype-annotate 此插件将与它们在已解析HTML文件中的目标匹配。 它将文本范围选择包装在mark元素中,并将属性和挂钩添加到匹配的位置,可在其他处理器或浏览器脚本中使用它们来实现进一步的行为。 注意:这会修改...
  • guard-annotate:笔记-源码

    2021-06-04 21:01:14
    Annotate guard 在需要时运行 annotate gem 与 Annotate 2.4.x 兼容 在 Ruby 1.8.7、1.9.x、2.1.x 上测试 安装 安装宝石: gem install guard - annotate 将 gem 添加到您的 Gemfile 中: gem 'guard-annotate'...
  • $ npm install --save-dev gulp-ng-annotate 用法 var gulp = require ( 'gulp' ) ; var ngAnnotate = require ( 'gulp-ng-annotate' ) ; gulp . task ( 'default' , function ( ) { return gulp . src ( 'src/app....
  • idea annotate启用

    2021-09-24 17:04:30
    多人开发项目过程中,idea有个很不错的功能就是集成版本控制工具,左侧边界点击有有显示行号的就不多说了,有个annotate功能是比较实用的,发生问题通常查看是谁的锅比较有效。但是刚刚安装的idea,annotate是灰色的...
  • annotate python

    千次阅读 2017-03-30 16:20:05
    import numpy as np import matplotlib.pyplot as plt ax = plt.subplot(111) t = np.arange(0.0, 5, 0.01) s = np.cos(2*np.pi*t) line = plt.plot(t, s, linewidth = 3)...plt.annotate('local max', xy = (4, 1), xy
  • ng-annotate-adf-plugin 插件来注释小部件。 与 gulp 一起使用 包.json { " devDependencies " : { " gulp " : " ^3.8.10 " , " gulp-load-plugins " : " ^0.8.0 " , " gulp-ng-annotate " : " ^0.5.2 " , " ...
  • annotate-sheildpay-源码

    2021-04-09 18:27:37
    欢迎使用annotate,这是一种教育工具,用于可视化正在运行JavaScript程序的基础操作。 从不同算法的下拉列表中进行选择,然后逐步完成获取和设置操作,这些操作会绘制算法进度。 每个操作的日志将显示在一侧,单击...
  • <div><p>I tabixed a bed format file and tried to use the gemini annotate function and received the following error: <p>Traceback (most recent call last): File "/usr/local/bin/gemini", line 5,...
  • Add ng-annotate

    2020-12-27 03:38:12
    You need to annotate them. I suggest using https://github.com/olov/ng-annotate</p> <p>I'd contribute to this if you like.</p><p>该提问来源于开源项目:bvaughn/angular-form-for</p></div>
  • Annotate PRO-crx插件

    2021-04-02 22:26:34
    Annotate Pro(AP)可以轻松创建,共享和使用专家反馈的库,以加快使用时评论和参与Google文档,画布,Microsoft团队,谷歌教室,微软Word,Schoology,Turnitin反馈工作室,Brightspace,Blackboard,Gmail,...
  • 主要介绍了django ORM之values和annotate使用详解,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 请注意, 现在支持在 .ng.js-files ( ) 上运行 ng-annotate 所以我将在该软件包上线后立即删除该软件包。 流星-ng-注释 在 angular 源上运行 ng-annotate 以简化 Meteor 上的 Angularjs 开发。 需要重命名js文件 我...
  • idea annotate 莫名消失

    2021-07-16 10:53:56
    idea annotate 莫名消失 iead使用过程中可能会遇到annotate突然置灰不可使用的情况,具体操作了什么导致annotate不可用笔者也不清楚自己操作了什么 可以按以下方式设置 选择自己的版本控制方式 有些idea版本设置...
  • 前端开源库-ng-annotate-loaderng annotate loader,在捆绑包上运行ng annotate的Webpack loader
  • jquery.annotate.js

    2013-12-19 19:37:18
    jquery.annotate.js包 为图片添加注释
  • 在 Vue2 Annotate 中通过 Annotate JS 生成自定义注解(面向切面编程) 本文基于在了解 Vue2 Annotate 框架基本用法后的进阶使用技巧 Vue2 Annotate 简介地址:https://palerock.cn/articles/001JPDEjZ87 Vue2 ...
  • 通过在annotate.tech创建一个免费帐户,用户可以将所有保存的注释全部取出。 在不创建帐户的情况下,注释仍然保存在页面级别的浏览器中。 除了大量的预设建议之外,用户还可以添加,编辑和删除建议。这使用户能够...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 25,054
精华内容 10,021
关键字:

annotate