Python plotly.graph_objs 模块，Layout() 实例源码

我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用plotly.graph_objs.Layout()。

项目：pymoku 作者：liquidinstruments | 项目源码 | 文件源码

def plot_frame(dataframe, uname=None, api_key=None, mode='lines', line={}):
    try:
        import plotly.plotly as ply
        import plotly.tools as ptls
        from plotly.graph_objs import Scatter, Layout, Data, Figure
    except ImportError:
        raise InvalidOperationException("Please install the Python plotly bindings")

    if uname and api_key:
        ply.sign_in(uname, api_key)

    c1 = dataframe.ch1
    c2 = dataframe.ch2
    x = list(range(len(c1)))

    t1 = Scatter(x=x, y=c1, mode=mode, line=line)
    t2 = Scatter(x=x, y=c2, mode=mode, line=line)

    layout = Layout(title="Moku:Lab Frame Grab")
    data = Data([t1, t2])

    fig = Figure(data=data, layout=layout)

    return ply.plot(fig)

项目：sound_field_analysis-py 作者：QULab | 项目源码 | 文件源码

def layout_2D(type=None, title=None):
    layout = go.Layout(
        title=title,
        xaxis=dict(
            title='Samples'
        ),
        yaxis=dict(
            title='Amplitude'
        )
    )

    if type == 'time':
        layout.title = 'Time domain plot'
        layout.xaxis.title = 'Time [s]'
    elif type == 'linFFT':
        layout.title = 'Frequency domain plot (linear)'
        layout.yaxis.title = 'Amplitude [dB]'
        layout.xaxis.title = 'Frequency [Hz]'
    elif type == 'logFFT':
        layout.title = 'Frequency domain plot (logarithmic)'
        layout.yaxis.title = 'Amplitude [dB]'
        layout.xaxis.title = 'Frequency [Hz]'
        layout.xaxis.type = 'log'
    return layout

项目：CoinTK 作者：CoinTK | 项目源码 | 文件源码

def plot_results(results, plot_name='temp-plot.html'):
    '''
        results is a list of dictionaries, each of which defines a trace
         e.g. [{'x': x_data, 'y': y_data, 'name': 'plot_name'}, {...}, {...}]

        Each dictionary's key-value pairs will be passed into go.Scatter
         to generate a trace on the graph

    '''
    traces = []

    for input_args in results:
        traces.append(go.Scatter(**input_args))

    layout = go.Layout(
        title='Trading performance over time',
        yaxis=dict(
            title='Value (USD)'
        ),
    )
    plot(go.Figure(data=traces, layout=layout), filename=plot_name)

项目：pongr 作者：wseaton | 项目源码 | 文件源码

def win_probability_matrix(matrix_df):
    'returns the win probability matrix plot as a plotly heatmap'

    trace = go.Heatmap(
        z=matrix_df.transpose().values.tolist(),
        x=matrix_df.columns[::-1],
        y=matrix_df.columns[::-1],
        colorscale='Viridis'
    )

    data = [trace]

    layout = go.Layout(
        title='Win Probability Matrix',
        xaxis=dict(title='Loser', ticks=''),
        yaxis=dict(title='Winner', ticks=''),
        height=750
    )

    return offl.plot(dict(data=data, layout=layout), output_type='div')

项目：vslam_evaluation 作者：nicolov | 项目源码 | 文件源码

def running_times():
    rospack = rospkg.RosPack()
    data_path = os.path.join(rospack.get_path('vslam_evaluation'), 'out')
    df = pd.read_csv(os.path.join(data_path, 'runtimes.txt'),
        header=None,
        index_col=0)

    bars = []

    for col_idx in df:
        this_stack = df[col_idx].dropna()
        bars.append(
            go.Bar(
                x=this_stack.index,
                y=this_stack.values,
                name='Thread {}'.format(col_idx)))

    layout = go.Layout(
        barmode='stack',
        yaxis={'title': 'Running time [s]'})

    fig = go.Figure(data=bars, layout=layout)

    url = py.plot(fig, filename='vslam_eval_run_times')

项目：idasec 作者：RobinDavid | 项目源码 | 文件源码

def generate_chart(self, _):
        try:
            import plotly
            import plotly.graph_objs as go
            data = [[0, 0, 0], [0, 0, 0]]
            ok, viol = self.results.get_ok_viol()
            x = ["OK (%d)" % ok, "Tampering (%d)" % viol]
            for ret in self.results:
                i = 1 if ret.is_tampering() else 0
                data[i][0] += ret.is_aligned()
                data[i][1] += ret.is_disaligned()
                data[i][2] += ret.is_single()
            final_data = [go.Bar(x=x, y=[x[0] for x in data], name="Aligned"), go.Bar(x=x, y=[x[1] for x in data], name="Disaligned"), go.Bar(x=x, y=[x[2] for x in data], name="Single")]
            fig = go.Figure(data=final_data, layout=go.Layout(barmode='group', title='Call stack tampering labels'))
            plotly.offline.plot(fig, output_type='file', include_plotlyjs=True, auto_open=True)
        except ImportError:
            self.log("ERROR", "Plotly module not available")

项目：neural-segmentation 作者：melsner | 项目源码 | 文件源码

def plotVAEplotly(self, logdir, prefix, ctable=None, reverseUtt=False, batch_size=128, debug=False):
        ticks = [[-1,-0.5,0,0.5,1]]*self.latentDim
        samplePoints = np.array(np.meshgrid(*ticks)).T.reshape(-1,3)
        input_placeholder = np.ones(tuple([len(samplePoints)] + list(self.phon.output_shape[1:-1]) + [1]))
        preds = self.decode_word([samplePoints, input_placeholder], batch_size=batch_size)
        if reverseUtt:
            preds = getYae(preds, reverseUtt)
        reconstructed = reconstructXae(np.expand_dims(preds.argmax(-1), -1), ctable, maxLen=5)

        data = [go.Scatter3d(
            x = samplePoints[:,0],
            y = samplePoints[:,1],
            z = samplePoints[:,2],
            text = reconstructed,
            mode='text'
        )]
        layout = go.Layout()
        fig = go.Figure(data=data, layout=layout)
        plotly.offline.plot(fig, filename=logdir + '/' + prefix + '_VAEplot.html', auto_open=False)

项目：finch 作者：chrisranderson | 项目源码 | 文件源码

def scatter_plot(xs, ys=None, xlabel='', ylabel='', title='', lines=False, marker=dict()):
  layout = Layout(
    title=title,
    xaxis=dict(title=xlabel),
    yaxis=dict(title=ylabel)
  )

  if ys is None:
    ys = xs
    xs = list(range(len(xs)))

  data = [
    Scatter(x=xs, 
            y=ys, 
            mode='lines' if lines else 'markers',
            marker=marker)
  ]

  figure = Figure(data=data, layout=layout)
  plotly.offline.plot(figure, filename=title + '.html')

项目：openkamer 作者：openkamer | 项目源码 | 文件源码

def get_example_plot_html(number_of_points=30):
    import plotly.offline
    from plotly.graph_objs import Scatter, Layout, Bar, Margin

    data_x = []
    data_y = []
    for i in range(0, number_of_points):
        data_x.append(i)
        data_y.append(random.randint(-10, 10))
    return plotly.offline.plot(
        figure_or_data={
            "data": [Scatter(x=data_x, y=data_y)],
            "layout": Layout(title="Plot Title")
        },
        show_link=False,
        output_type='div',
        include_plotlyjs=False,
        auto_open=False,
    )

项目：memote 作者：opencobra | 项目源码 | 文件源码

def scatter_line_chart(df, y_title):
    """Generate a reproducible plotly scatter and line plot."""
    if len(df.columns) == 3:
        x_axis, y_axis, factor = df.columns
        data = go.Data([
            go.Scatter(x=sub[x_axis], y=sub[y_axis], name=key)
            for key, sub in df.groupby(factor, as_index=False, sort=False)])
    else:
        x_axis, y_axis = df.columns
        data = go.Data([
            go.Scatter(x=df[x_axis], y=df[y_axis])])
    layout = go.Layout(
        width=650,
        height=500,
        xaxis=go.XAxis(
            title="Commit Hash" if x_axis == "commit_hash" else "Timestamp",
            tickangle=-45 if x_axis == "commit_hash" else 0
        ),
        yaxis=go.YAxis(
            title=y_title
        )
    )
    return Markup(py.plot(go.Figure(data=data, layout=layout), **_DEFAULT_ARGS))

项目：sound_field_analysis-py 作者：QULab | 项目源码 | 文件源码

def plot3D(vizMTX, style='shape', layout=None, normalize=True, logScale=False):
    """Visualize matrix data, such as from makeMTX(Pnm, dn)

    Parameters
    ----------
    vizMTX : array_like
       Matrix holding spherical data for visualization
    style : string{'shape', 'sphere', 'flat'}, optional
       Style of visualization. [Default: 'shape']
    normalize : Bool, optional
       Toggle normalization of data to [-1 ... 1] [Default: True]

    TODO
    ----
    Colorization, contour plot
    """

    if style == 'flat':
        layout = go.Layout(
            scene=dict(
                xaxis=dict(range=[0, 360]),
                yaxis=dict(range=[0, 181]),
                aspectmode='manual',
                aspectratio=dict(x=3.6, y=1.81, z=1)
            )
        )

    showTrace(genVisual(vizMTX, style=style, normalize=normalize, logScale=logScale), layout=layout)

项目：black_holes 作者：codeforgoodconf | 项目源码 | 文件源码

def build(self, x, y, title=""):
        div = plotly.offline.plot({
            "data": [Scatter(x=x, y=y)],
            "layout": Layout(title=title,
                             # xaxis=dict(range=[4200, 5300]),
                             # yaxis=dict(range=[0.5, 2]),
                             )
        }, output_type='div', include_plotlyjs=False)

        return div

项目：singlecell-dash 作者：czbiohub | 项目源码 | 文件源码

def callbacks(self, app):

        @app.callback(
            Output(self.ID, 'figure'),
            [Input(self.SUBSET_ID, 'value'),
             # Input(SmushedPlot.SELECTED_GENE_ID, 'value'),
             # Input(SmushedPlot.SELECTED_METADATA_ID, 'value')
             ])
        def update_reads_vs_genes(group_name, selected_gene=None,
                                  selected_metadata=None):
            """When a group is selected, update the reads v genes scatter"""

            group_barcodes = self._get_dropdown_barcodes(group_name)
            group_metadata_subset = self.cell_metadata.loc[group_barcodes]

            x = group_metadata_subset[self.n_molecules_col]
            y = group_metadata_subset[self.n_genes_col]


            return {
                "data": [go.Scatter(x=x,
                                    y=y,
                                    mode='markers', hoverinfo='text',
                                    text=group_metadata_subset.index,
                                    customdata=group_metadata_subset.index)],
                "layout": go.Layout(xaxis={'title': 'Reads per cell'},
                                    yaxis={'title': "Genes per cell"},
                                    margin={'b': 40, 't': 10, 'r': 0},
                                    hovermode='closest', dragmode='select'),
            }

项目：singlecell-dash 作者：czbiohub | 项目源码 | 文件源码

def plot_labelprop(coords, communities, filename=None, title=''):
    scatters = []

    n_communities = len(np.unique(communities))

    scatter = go.Scatter(x=coords[0],
                         y=coords[1],
                         mode='markers',
                         name=communities,
                         hoverinfo='text',
                         text=communities,
                         marker=dict(color=communities,
                                     cmin=0.0, cmax=n_communities - 1,
                                     colorscale='Viridis'
                                     ))

    fig = {
        'data': [scatter],
        "layout": go.Layout(title=f'Graph layout of cell type clusters: {title}',
                            xaxis={'showticklabels': False},
                            yaxis={'showticklabels': False},
                            hovermode='closest', dragmode='select',
                            show_legend=True)
    }

    if filename is None:
        plotly.offline.iplot(fig)
    else:
        plotly.offline.plot(fig, filename=filename, image='png')

项目：takeout-inspector 作者：cdubz | 项目源码 | 文件源码

def label_usage(self):
        """Returns a pie chart showing usage information for labels.
        """
        c = self.conn.cursor()

        c.execute('''SELECT gmail_labels FROM messages
            WHERE gmail_labels != '' AND gmail_labels NOT LIKE '%Chat%';''')

        counts = {}
        for row in c.fetchall():
            for label in row[0].split(','):
                if label not in counts:
                    counts[label] = 0
                counts[label] += 1

        trace = pgo.Pie(
            labels=counts.keys(),
            values=counts.values(),
            marker=dict(
                colors=[
                    self.config.get('color', 'primary'),
                    self.config.get('color', 'secondary'),
                ]
            )
        )

        layout_args = plotly_default_layout_options()
        layout_args['title'] = 'Label Usage'
        del layout_args['xaxis']
        del layout_args['yaxis']

        layout = pgo.Layout(**layout_args)

        return plotly_output(pgo.Figure(data=[trace], layout=layout))

项目：takeout-inspector 作者：cdubz | 项目源码 | 文件源码

def thread_sizes(self):
        """Returns a graph showing thread size information. A "thread" must consist of more than one email.
        """
        c = self.conn.cursor()

        c.execute('''SELECT COUNT(message_key) AS message_count
            FROM messages
            WHERE gmail_labels NOT LIKE '%Chat%'
            GROUP BY gmail_thread_id
            HAVING message_count > 1;''')

        counts = {}
        for row in c.fetchall():
            if row[0] not in counts:
                counts[row[0]] = 0
            counts[row[0]] += 1

        data = dict(
            x=counts.keys(),
            y=counts.values(),
            name='Emails in thread',
            mode='lines+markers',
            marker=dict(
                color=self.config.get('color', 'primary'),
            ),
        )

        layout_args = plotly_default_layout_options()
        layout_args['title'] = 'Thread Sizes'
        layout_args['xaxis']['title'] = 'Number of messages'
        layout_args['yaxis']['title'] = 'Number of threads'
        layout = pgo.Layout(**layout_args)

        return plotly_output(pgo.Figure(data=[pgo.Scatter(**data)], layout=layout))

项目：takeout-inspector 作者：cdubz | 项目源码 | 文件源码

def talk_times(self):
        """Returns a plotly graph showing chat habits by hour of the day (UTC).
        """
        c = self.conn.cursor()

        c.execute('''SELECT strftime('%H', `date`) AS hour, COUNT(message_key) AS talk_messages
            FROM messages
            WHERE gmail_labels LIKE '%Chat%'
            GROUP BY hour
            ORDER BY hour ASC;''')

        data = OrderedDict()
        for row in c.fetchall():
            data[row[0]] = row[1]

        total_messages = sum(data.values())
        percentages = OrderedDict()
        for hour in data.keys():
            percentages[hour] = str(round(float(data[hour])/float(total_messages) * 100, 2)) + '%'

        data_args = dict(
            x=data.keys(),
            y=data.values(),
            text=percentages.values(),
            name='Chat messages',
            marker=dict(
                color=self.config.get('color', 'primary')
            ),
            fill='tozeroy',
        )

        layout_args = plotly_default_layout_options()
        layout_args['title'] = 'Chat Times (UTC)'
        layout_args['xaxis']['title'] = 'Hour of day (UTC)'
        layout_args['yaxis']['title'] = 'Chat messages'

        trace = pgo.Scatter(**data_args)
        layout = pgo.Layout(**layout_args)

        return plotly_output(pgo.Figure(data=[trace], layout=layout))

项目：kindel 作者：bede | 项目源码 | 文件源码

def plotly_samtools_depth(ids_depths):
    n_positions = len(ids_depths[max(ids_depths, key=lambda x: len(set(ids_depths[x])))])
    traces = []
    for id, depths in sorted(ids_depths.items()):
        traces.append(
            go.Scattergl(
                x=list(range(1, n_positions)),
                y=depths,
                mode='lines',
                name=id,
                text=id))
    layout = go.Layout(
        title='Depth of coverage',
        xaxis=dict(
            title='Position',
            gridcolor='rgb(255, 255, 255)',
            gridwidth=2),
        yaxis=dict(
            title='Depth',
            gridcolor='rgb(255, 255, 255)',
            gridwidth=2,
            type='log'),
        paper_bgcolor='rgb(243, 243, 243)',
        plot_bgcolor='rgb(243, 243, 243)')

    fig = go.Figure(data=traces, layout=layout)
    py.plot(fig, filename='depths.html')

项目：kindel 作者：bede | 项目源码 | 文件源码

def plotly_variants(ids_data):
    import plotly.offline as py
    import plotly.graph_objs as go
    traces = []
    for id, data in sorted(ids_data.items()):
        traces.append(
            go.Scattergl(
                x=data['pos'],
                y=data['max_alt'],
                mode='markers',
                name=id,
                text=id))
    layout = go.Layout(
        title='Variants',
        xaxis=dict(
            title='Position',
            gridcolor='rgb(255, 255, 255)',
            gridwidth=2),
        yaxis=dict(
            title='Abundance',
            gridcolor='rgb(255, 255, 255)',
            gridwidth=2,
            type='linear'),
        paper_bgcolor='rgb(243, 243, 243)',
        plot_bgcolor='rgb(243, 243, 243)')

    fig = go.Figure(data=traces, layout=layout)
    py.plot(fig, filename='variants.html')

项目：bowtie 作者：jwkvam | 项目源码 | 文件源码

def callback(*args):
    """dummy function"""
    # pylint: disable=unused-argument
    chart = {
        "data": [
            Scatter(x=[1, 2, 3, 4], y=[4, 1, 3, 7])
        ],
        "app": PlotLayout(
            title="hello world"
        )
    }
    viz.do_all(chart)


# pylint: disable=unused-argument

项目：gRPC-Makerboards 作者：PeridotYouClod | 项目源码 | 文件源码

def createGraph(num_points, colname):
  sensor_data = GenScatterData(colname, num_points)
  plotly.offline.plot({
    'data': [
        GenScatter(sensor_data),
    ],
    'layout': Layout(title='Data for %s' % colname)
  })