コード例 #1
0
ファイル: drawer.py プロジェクト: stungkit/zvt
    def make_traces(self,
                    main_chart=ChartType.kline,
                    sub_chart="bar",
                    yaxis="y",
                    scale_value=None,
                    **kwargs):
        traces = []
        sub_traces = []

        for entity_id, df in self.main_data.entity_map_df.items():
            df = df.select_dtypes(np.number)
            df = df.copy()
            if scale_value:
                for col in df.columns:
                    first = None
                    for i in range(0, len(df)):
                        first = df[col][i]
                        if first != 0:
                            break
                    if first == 0:
                        continue
                    scale = scale_value / first
                    df[col] = df[col] * scale
            code = entity_id
            try:
                _, _, code = decode_entity_id(entity_id)
            except Exception:
                pass

            # 构造主图
            if main_chart == ChartType.bar:
                for col in df.columns:
                    trace_name = "{}_{}".format(code, col)
                    ydata = df[col].values.tolist()
                    traces.append(
                        go.Bar(x=df.index,
                               y=ydata,
                               name=trace_name,
                               yaxis=yaxis,
                               **kwargs))
            elif main_chart == ChartType.kline:
                trace_name = "{}_kdata".format(code)
                trace = go.Candlestick(
                    x=df.index,
                    open=df["open"],
                    close=df["close"],
                    low=df["low"],
                    high=df["high"],
                    name=trace_name,
                    yaxis=yaxis,
                    **kwargs,
                )
                traces.append(trace)
            elif main_chart in [
                    ChartType.scatter, ChartType.line, ChartType.area
            ]:
                mode = _zvt_chart_type_map_scatter_mode.get(main_chart)
                for col in df.columns:
                    trace_name = "{}_{}".format(code, col)
                    ydata = df[col].values.tolist()
                    traces.append(
                        go.Scatter(x=df.index,
                                   y=ydata,
                                   mode=mode,
                                   name=trace_name,
                                   yaxis=yaxis,
                                   **kwargs))
            elif main_chart == ChartType.histogram:
                for col in df.columns:
                    trace_name = "{}_{}".format(code, col)
                    x = df[col].tolist()
                    trace = go.Histogram(x=x, name=trace_name, **kwargs)
                    traces.append(trace)
                    annotation = [
                        dict(
                            entity_id=entity_id,
                            timestamp=x[-1],
                            value=0,
                            flag=f"{trace_name}:{x[-1]}",
                        )
                    ]
                    annotation_df = pd.DataFrame.from_records(
                        annotation, index=["entity_id", "timestamp"])
                    if pd_is_not_null(self.annotation_df):
                        self.annotation_df = pd.concat(
                            [self.annotation_df, annotation_df])
                    else:
                        self.annotation_df = annotation_df
            elif main_chart == ChartType.pie:
                for _, row in df.iterrows():
                    traces.append(
                        go.Pie(name=entity_id,
                               labels=df.columns.tolist(),
                               values=row.tolist(),
                               **kwargs))
            else:
                assert False

            # 构造主图指标
            if self.factor_data_list:
                for factor_data in self.factor_data_list:
                    if not factor_data.empty():
                        factor_df = factor_data.entity_map_df.get(entity_id)
                        factor_df = factor_df.select_dtypes(np.number)
                        if pd_is_not_null(factor_df):
                            for col in factor_df.columns:
                                trace_name = "{}_{}".format(code, col)
                                ydata = factor_df[col].values.tolist()

                                line = go.Scatter(x=factor_df.index,
                                                  y=ydata,
                                                  mode="lines",
                                                  name=trace_name,
                                                  yaxis=yaxis,
                                                  **kwargs)
                                traces.append(line)

            # 构造幅图
            if self.has_sub_plot():
                for sub_data in self.sub_data_list:
                    sub_df = sub_data.entity_map_df.get(entity_id)
                    if pd_is_not_null(sub_df):
                        sub_df = sub_df.select_dtypes(np.number)
                        for col in sub_df.columns:
                            trace_name = "{}_{}".format(code, col)
                            ydata = sub_df[col].values.tolist()

                            def color(i):
                                if i > 0:
                                    return "red"
                                else:
                                    return "green"

                            colors = [color(i) for i in ydata]

                            the_sub_chart = None
                            if self.sub_col_chart is not None:
                                the_sub_chart = self.sub_col_chart.get(col)
                            if not the_sub_chart:
                                the_sub_chart = sub_chart

                            if the_sub_chart == ChartType.line:
                                sub_trace = go.Scatter(
                                    x=sub_df.index,
                                    y=ydata,
                                    name=trace_name,
                                    yaxis="y2",
                                    marker=dict(color=colors))
                            else:
                                sub_trace = go.Bar(x=sub_df.index,
                                                   y=ydata,
                                                   name=trace_name,
                                                   yaxis="y2",
                                                   marker=dict(color=colors))
                            sub_traces.append(sub_trace)

        return traces, sub_traces
コード例 #2
0
## Describing data according to the Feedback

Alexa_train.groupby('feedback').describe()

### Data Visulization

## Distribution of ratings of Alexa

ratings = Alexa_train['rating'].value_counts()
label_rating = ratings.index
size_rating = ratings.values

Colors = ['pink', 'lightblue', 'aqua', 'gold', 'crimson']
rating_Piechart = go.Pie(labels=label_rating,
                         values=size_rating,
                         marker=dict(colors=Colors),
                         name='Alexa',
                         hole=0.3)

df = [rating_Piechart]
layout = go.Layout(title='Distribution of Ratings for Alexa')
fig = go.Figure(data=df, layout=layout)
#fig=go.Figure(data=[go.Pie(labels=label_rating,values=size_rating,marker=dict(colors=Colors),name='Alexa',hole=0.3)],layout=layout)

py.offline.plot(fig, filename='Pie_Chart1.html')

### BAR PLOT
#linespace

color = plt.cm.copper(np.linspace(0, 1, 15))
Alexa_train['variation'].value_counts().plot.bar(color=color, figsize=(15, 9))
コード例 #3
0
    {
        'data': [Q2_Top5Plot_Bronx],
        'layout': {
            'title': 'Top 5 complaints for the borough of Bronx',
            'margin': {
                'l': '180'
            }
        }
    },
    filename='Q2_Top5_Bronx')

# Q3. Proportion of Open, Closed and Pending Complaints
ComplaintStatus_Q3 = spark.sql(
    'SELECT Status,COUNT(Status) AS Counts FROM TABLE GROUP BY STATUS')
Q3_PieComplaintStatus = go.Pie(labels=ComplaintStatus_Q3.toPandas()['Status'],
                               values=ComplaintStatus_Q3.toPandas()['Counts'],
                               textinfo='label+percent')
py.plot(
    {
        'data': [Q3_PieComplaintStatus],
        'layout': {
            'title': 'Proportion of Closed and Open complaints'
        }
    },
    filename='Q3_ComplaintStatus',
    image='png')

# Q4. Total Complaints over the years
Q4_TotalComplaints = spark.sql(
    'SELECT COUNT(*) AS `Number of Complaints`,SUBSTRING(`Created Date`,0,4) AS Year FROM TABLE GROUP BY SUBSTRING(`Created Date`,0,4) ORDER BY Year desc'
)
コード例 #4
0
def interactive():
    response = ''
    while True:
        response = input('Enter a command: ')
        if response.strip() == '':
            continue
        if response == 'help':
            print(help_text)
            continue
        elif response == 'exit':
            print("bye")
            break
        elif response[:
                      24] == 'tv popularity and rating' or response[:
                                                                    21] == 'tv country and rating' or response[:
                                                                                                               22] == 'tv #released per month' or response[:
                                                                                                                                                           20] == 'tv ratings and month':
            try:
                tuple = process_command(response)
            except:
                print("Command not recognized: " + response)
                continue
            length_format = []
            if not tuple:
                print("No matched results")
                continue
            if response[:24] == 'tv popularity and rating':
                tuple_print = [('TvName', 'Popularity', 'Rating')] + tuple
            elif response[:21] == 'tv country and rating':
                tuple_print = [('Country', 'Rating')] + tuple
            elif response[:22] == 'tv #released per month':
                tuple_print = [('Month', 'Count')] + tuple
            elif response[:20] == 'tv ratings and month':
                tuple_print = [('Month', 'Avg Rating')] + tuple
            else:
                continue

            # print out results
            for index in range(len(tuple_print[0])):
                maxlen = -1
                for row1 in tuple_print:
                    if len(str(row1[index])) > maxlen:
                        maxlen = len(str(row1[index]))
                length_format.append(maxlen)
            for line_temp in tuple_print:
                for j in range(len(line_temp)):
                    format_string = "{0:<" + str(length_format[j]) + "s}"
                    print(format_string.format(str(line_temp[j])), end="  ")
                print("")

            if response[:24] == 'tv popularity and rating':
                x_rating = []
                y_popularity = []
                for line_data in tuple:
                    y_popularity.append(line_data[1])
                    x_rating.append(line_data[2])

                trace = go.Scatter(x=x_rating, y=y_popularity, mode='markers')

                layout = dict(title='Population v.s. rating',
                              xaxis_title="Rating",
                              yaxis_title="Popularity")
                data = [trace]
                fig = go.Figure(data=data)
                fig = fig.update_layout(layout)
                fig.write_html('scatter.html', auto_open=True)
            elif response[:21] == 'tv country and rating':
                x_bar = []  # rating
                y_bar = []  # country
                for line_data in tuple:
                    x_bar.insert(0, line_data[1])
                    y_bar.insert(0, line_data[0])
                trace = go.Bar(x=x_bar,
                               y=y_bar,
                               orientation='h',
                               marker=dict(color='rgba(246, 78, 139, 0.8)', ))

                layout = dict(title='Barplot of country with Tv rating',
                              xaxis_title="Rating",
                              yaxis_title="Country")
                data = [trace]
                fig = go.Figure(data=data)
                fig = fig.update_layout(layout)
                fig.write_html('bar.html', auto_open=True)

            elif response[:22] == 'tv #released per month':
                values_pie = []
                labels_pie = [
                    'January', 'February', 'March', 'April', 'May', 'June',
                    'July', 'August', 'September', 'October', 'November',
                    'December'
                ]
                for line_data in tuple:
                    values_pie.append(line_data[1])
                trace = go.Pie(
                    labels=labels_pie,
                    values=values_pie,
                    sort=False,
                )

                layout = dict(
                    title='Pie chart of the number of TVs per month', )
                data = [trace]
                fig = go.Figure(data=data)
                fig = fig.update_layout(layout)
                fig.write_html('pie.html', auto_open=True)
            elif response[:20] == 'tv ratings and month':
                x_line = []
                y_line = []
                for line_data in tuple:
                    x_line.append(line_data[0])
                    y_line.append(line_data[1])
                trace = go.Scatter(x=x_line,
                                   y=y_line,
                                   mode='lines+markers',
                                   name='lines+markers')

                layout = dict(title='Line chart of ratings v.s. month in 2018',
                              xaxis_title="Month",
                              yaxis_title="Rating")
                data = [trace]
                fig = go.Figure(data=data)
                fig = fig.update_layout(layout)
                fig.write_html('line.html', auto_open=True)
        else:
            print("Command not recognized: " + response)
コード例 #5
0
    Header(),

    #dcc.Link('', href='/jrc/job_analysis', className="tab"),
    # Row 3
    html.Div([
        html.Div([
            html.H6(["Distribution of job as per Years of Experience"],
                    className="gs-header gs-table-header padded")
        ],
                 className="row "),
        html.Div([
            dcc.Graph(id='graph-4',
                      figure={
                          'data': [
                              go.Pie(labels=labels,
                                     values=val,
                                     name="Years of Experience",
                                     hoverinfo='label+value+percent+name')
                          ],
                          'layout': {
                              'height': 500,
                              'clickmode': 'event+select'
                          }
                      }),
        ],
                 className="row ")
    ],
             className="subpage1")
])

#Layout for time series trend for job openings
tra = html.Div([
def update_revenue(year, region, state, service):
    filtered_data = car_data
    if year != 'All':
        filtered_data = filtered_data[filtered_data['invoice_year'] == int(
            year)]
    if region != 'All':
        filtered_data = filtered_data[filtered_data['Region'] == region]
    if state != 'All':
        filtered_data = filtered_data[filtered_data['State'] == state]
    if service != 'All':
        filtered_data = filtered_data[filtered_data['Order Type'] == service]
    revenue_data = filtered_data
    class_revenue = pd.DataFrame(
        revenue_data.groupby([
            'Car_Class'
        ])['Total Amt Wtd Tax.'].sum()).sort_values(by='Total Amt Wtd Tax.',
                                                    ascending=False)
    fig_1 = go.Figure(data=[
        go.Pie(labels=class_revenue.index,
               values=class_revenue['Total Amt Wtd Tax.'])
    ])
    fig_1.update_traces(hoverinfo='label+value',
                        textinfo='percent',
                        textfont_size=20,
                        hole=0.4)
    fig_1.update_layout(title_text="Distribution of Revenue by Car Class",
                        annotations=[
                            dict(text=state,
                                 x=0.5,
                                 y=0.5,
                                 font_size=15,
                                 showarrow=False)
                        ])

    make_count = pd.DataFrame(
        revenue_data.groupby([
            'Make'
        ])['Total Amt Wtd Tax.'].sum()).sort_values(by='Total Amt Wtd Tax.',
                                                    ascending=False).head(15)
    fig_2 = go.Figure(
        data=[go.Bar(x=make_count.index, y=make_count['Total Amt Wtd Tax.'])])

    fig_2.update_layout(title_text="Revenue by Car Companies",
                        xaxis=dict(title='Car Make',
                                   categoryorder='total descending'),
                        yaxis=dict(title='Revenue'))

    # fig_2 = go.Figure(data=[go.Pie(labels = make_count.index,
    # 	values=make_count['Regn No'])])
    # fig_2.update_traces(hoverinfo='label+value', textinfo='percent', textfont_size=20, hole = 0.4)
    # fig_2.update_layout(title_text = "Car Make: {}".format(state), annotations=[dict(text = state, x = 0.5, y = 0.5, font_size=15, showarrow=False)])
    model_count = pd.DataFrame(
        revenue_data.groupby([
            'Model'
        ])['Total Amt Wtd Tax.'].sum()).sort_values(by='Total Amt Wtd Tax.',
                                                    ascending=False).head(15)
    fig_3 = go.Figure(data=[
        go.Bar(x=model_count.index, y=model_count['Total Amt Wtd Tax.'])
    ])

    fig_3.update_layout(title_text="Revenue by Car Models",
                        xaxis=dict(title='Car Model',
                                   categoryorder='total descending'),
                        yaxis=dict(title='Revenue'))

    return fig_1, fig_2, fig_3
コード例 #7
0
ファイル: three_charts.py プロジェクト: dak529/Chart-Gallery
#pie_data = [
#   {"company": "Company X", "market_share": 0.55},
#  {"company": "Company Y", "market_share": 0.30},
# {"company": "Company Z", "market_share": 0.15}
#]

#print("----------------")
#print("GENERATING PIE CHART...")
#print(pie_data) # TODO: create a pie chart based on the pie_data

import plotly
import plotly.graph_objs as go
colors = ['gold', 'mediumturquoise', 'darkorange']
fig = go.Figure(data=[
    go.Pie(labels=['Company X', 'Company Y', 'Company Z'],
           values=[0.55, 0.30, 0.15])
])
#layout=(title="Pie Chart"))])
#layout(title="Pie Chart")
fig.update_traces(hoverinfo='label+percent',
                  textinfo='value',
                  textfont_size=20,
                  marker=dict(colors=colors,
                              line=dict(color='#000000', width=2)))
fig.show()

#
# CHART 2 (LINE)
#

#line_data = [
コード例 #8
0
                 value='Claim Amount'),
                      className='col-3'),
             html.Div([
                 ## Graph Pie
                 dcc.Graph(
                     id='contoh-graph-pie',
                     figure={
                         'data': [
                             go.Pie(labels=[
                                 '{}'.format(i) for i in
                                 list(dfTsa_plot[
                                     'Claim Type'].unique())
                             ],
                                    values=[
                                        dfTsa_plot.groupby(
                                            'Claim Type').
                                        mean()
                                        ['Claim Amount'][i]
                                        for i in
                                        list(dfTsa_plot[
                                            'Claim Type'].
                                             unique())
                                    ],
                                    sort=False)
                         ],
                         'layout': {
                             'title': 'Mean Pie Chart'
                         }
                     })
             ])
         ])
 ],
コード例 #9
0
def update_graph(select_index):


    if select_index == '1':
        figure = {
            'data': [
                go.Scatter(
                    x=d1['日期'].tolist(),
                    y=d1[yi].tolist(),
                    mode='lines',
                    name=city+yi
                               ) for yi in ['最高温度','最低温度','紫外线强度指数']
            ],

            'layout': [
                go.Layout(
                    height=350,
                    hovermode='closest',
                    title='折线图'
                )
            ]
        }
        return figure
    elif select_index == '2':
        figure = {
            'data': [
                go.Bar(
                    x=d1['日期'].tolist(),
                    y=d1[yi].tolist(),
                    name=city+yi
                ) for yi in ['相对湿度','能见度(公里)','风速(公里/小时)']],

            'layout': [
                go.Layout(
                    height=350,
                    hovermode='closest',
                    title='条形图',
                )
            ]
        }
        return figure

    elif select_index=='3':
        figure = {
            'data': [
                go.Pie(
                    labels=quality_level,
                    values=quality_count,
                    name='legend'
                )],

            'layout': [
                go.Layout(
                    height=350,
                    hovermode='closest',
                    title='饼状图'
                )
            ]
        }
        return figure

    elif select_index=='4':
        figure = {
            'data': [
                go.Scatter(
                    x=df3['Longitude'].tolist(),
                    y=df3['Latitude'].tolist(),
                    text = df3['text'].tolist(),
                    mode='markers',
                    marker={'size': 15},
                    name='legend'
                )],

            'layout': [
                go.Layout(
                    height=350,
                    hovermode='closest',
                    title ='散点图'
                )
            ]
        }
        return figure
コード例 #10
0
    top5_average_rating = round(top5_rating_sum/top5_num,2)

    #calculate all average rating
    all_num=0
    all_rating_sum=0
    for i in range(0,10):
        all_num+=all_value_lst[i]
    for i in range(0,10):
        all_rating_sum+=float(all_value_lst[i])*float(all_key_lst[i])
    all_average_rating = round(all_rating_sum/all_num,2)

    #save chart to image and render
    trace1 = go.Pie(
	labels=top5_key_lst,
	values=top5_value_lst,
	domain=dict(x=[0,0.4], y=[0,0.4]),
        sort=False,
	hole=0.4
    )
    trace2 = go.Bar(
	x=top5_key_lst,
	y=top5_value_lst,
	xaxis='x2',
	yaxis='y2',
	marker=dict(color="maroon"),
	showlegend=False
    ) 
    trace3 = go.Pie(
	labels=all_key_lst,
	values=all_value_lst,
	domain=dict(x=[0,0.4], y=[0.6,1]),
コード例 #11
0
state_average_funding = pd.DataFrame({'Donor State':donor_state_amount_project['Donor State'][-5:][::-1],'Average Funding':val[-5:][::-1]})
sns.barplot(x="Donor State",y="Average Funding",data=state_average_funding)

# # <a id='4-6'>4.6 Percentage of donors as teachers</a>

# In[ ]:


per_teacher_as_donor = donors['Donor Is Teacher'].value_counts().to_frame().reset_index()
per_teacher_as_donor = per_teacher_as_donor.rename(columns= {'index': 'Types'})
labels = ['Donor is a Teacher','Donor is not a Teacher']
values = per_teacher_as_donor['Donor Is Teacher'].tolist()
colors = ['#96D38C', '#E1396C']
trace = go.Pie(labels=labels, values=values,
               hoverinfo='label+percent', textinfo='value',
               textfont=dict(size=20),
               marker=dict(colors=colors,
                           line=dict(color='#000000', width=2)))
py.iplot([trace], filename='styled_pie_chart')

# # <a id='4-7'>4.7 Top Donor Checked Out carts</a>

# In[ ]:


temp = donors_donations['Donor Cart Sequence'].value_counts().head()
df = pd.DataFrame({'labels': temp.index,'values': temp.values})
labels = df['labels'].tolist()
values = df['values'].tolist()
colors = ['#96D38C', '#E1396C','#C0C0C0','#FF0000','#F08080']
trace = go.Pie(labels=labels, values=values,
コード例 #12
0
"""# Participación de los Cuentahabientes Garantizados"""

import plotly.graph_objects as go

fig = go.Figure()

x1 = ['BANPRO', 'BANCENTRO', 'BAC', 'BDF', 'FICOHSA', 'AVANZ', 'ATLANTIDA']

y1 = [33.9, 35.6, 22.5, 4.0, 1.5, 2.5, 0.007]

colors_bancos = [
    '#66A731', '#006837', '#E3002B', '#0075BF', '#07C0DB', '#F48028', '#A61A11'
]

fig.add_trace(
    go.Pie(labels=x1, values=y1, hole=.4, marker_colors=colors_bancos))

fig.update_layout(
    barmode='stack',
    xaxis_type='category',
    title=
    '<b></b><b>Participación de los Cuentahabientes Garantizados</b><br><i>Porcentajes</i><br><i>31 de Agosto 2020</i>',
    paper_bgcolor='rgb(255, 255, 255)',
    plot_bgcolor='rgb(255, 255, 255)',
    font=dict(family="Courier New, monospace", size=18, color="#000000"),
    annotations=[
        dict(
            x=1,  #0.5,
            y=-0.20,  #-0.15,
            showarrow=False,
            text="Fuente: FOGADE",
コード例 #13
0
us = csv.reader(userfile)
next(us, None)

countmovies = len(list(mv))
countusers = len(list(us))
moviefile.seek(0)
userfile.seek(0)


def Cloning(li1):
    li_copy = list(li1)
    return li_copy


moviefile.seek(0)
gencount = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
genre = [
    'Biography', 'Horror', 'Crime', 'Animation', 'Musical', 'Romance',
    'Family', 'Comedy', 'Thriller', 'Mystery', 'History', 'Sci-Fi', 'Fantasy',
    'Drama', 'Sport', 'War'
]
listd = []
for row in mv:
    listd = (row[8])
    for j in range(0, 16):
        if listd.find(genre[j]) != -1:
            gencount[j] += 1

trace = go.Pie(labels=genre, values=gencount)
py.offline.plot([trace], filename='genre_splitup.html', auto_open=False)
print("Generated Genre Splitup")
コード例 #14
0
ファイル: dashboard.py プロジェクト: katiamega/dbis
    movies.movie_name,
    COUNT(cinema_session.ticket_number_fk)
FROM
    cinema_session INNER JOIN movies ON cinema_session.movie_id_fk = movies.movie_id
GROUP BY
    movies.movie_name
""")

movies = []
movie_tickets_count = []

for row in cursor.fetchall():
    movies.append(row[0])
    movie_tickets_count.append(row[1])

pie = go.Pie(labels=movies, values=movie_tickets_count)
movies_proportion_url = py.plot([pie], filename='movies-proportion')
""" create plot 3  """

cursor.execute("""
SELECT
    cinema_session.buy_date, COUNT(cinema_session.ticket_number_fk)
FROM
    cinema_session
GROUP BY
    cinema_session.buy_date
ORDER BY
    cinema_session.buy_date
""")

buy_dates = []
コード例 #15
0
                        title="Fare Distribution",
                        xaxis_title="Passanger ID",
                        yaxis_title="Fare"

                    )
                ),
                config={
                    'displayModeBar': False
                }
            ),
        ], className="six columns"),
        html.Div([
            dcc.Graph(
                id='graph3',
                figure=go.Figure(
                    data=[go.Pie(
                        labels=barData.json()['labels'],
                        values=barData.json()['values']
                    )],
                    layout=go.Layout(
                        title="Passanger Class Distribution",
                    )
                ),
                config={
                    'displayModeBar': False
                }
            )
        ], className="six columns")
    ], className="row")
])
コード例 #16
0
                 'plot_bgcolor': colors['plot_color'],
                 'paper_bgcolor': colors['paper_color'],   
                 'title': 'Visitors Count',
                 'font':{
                     'color': colors['text']
                 }
             }
         }
     )
 ]),
 
 html.Div([
     dcc.Graph(
         id = 'pie',
         figure=go.Figure(
                 data = [ go.Pie(labels = data_gen.states, values = data_gen.states_cnt)],
                 layout= go.Layout(
                     title =  'Statewise vistors'
                 )
         )
     )
 ]),
 
 html.Div([
     dcc.Graph(
         id = 'page-visits',
         figure=go.Figure(
                 data = [ go.Bar(x = data_gen.pages, y = data_gen.pg_cnt)],
                 layout= go.Layout(
                     title =  'Statewise vistors'
                 )
コード例 #17
0
sns.scatterplot(x=Combined_data['latitude'], y=Combined_data['longitude'])
plt.show()

sns.catplot(x='room_type', kind='count', data=Combined_data)
fig = plt.gcf()
fig.set_size_inches(8, 6)
plt.show()

import plotly.offline as pyo
import plotly.graph_objs as go
roomdf = Combined_data.groupby(
    'room_type').size() / Combined_data['room_type'].count() * 100
labels = roomdf.index
values = roomdf.values
# Use `hole` to create a donut-like pie chart
fig = go.Figure(data=[go.Pie(labels=labels, values=values, hole=.6)])
plt.show()

plt.figure(figsize=(10, 6))
sns.countplot(x='room_type', hue="neighbourhood", data=Combined_data)
plt.title("Room types occupied by the neighbourhood")
plt.show()

#catplot room type and price
plt.figure(figsize=(10, 6))
sns.catplot(x="room_type", y="price", data=Combined_data)
plt.ioff()

fig, axes = plt.subplots(1, 2, figsize=(21, 6))

sns.distplot(Combined_data['minimum_nights'],
コード例 #18
0
# Create the option to display charts that show the stats
# for gender representation for the last 120 years
if st.sidebar.checkbox("Gender Representation"):
    male = df[df["Sex"] == "M"]["ID"].agg("count")
    female = df[df["Sex"] == "F"]["ID"].agg("count")

    fig1 = px.histogram(df,
                        x="Year",
                        color="Sex",
                        title="Gender Representation 1896-2016")
    st.plotly_chart(fig1)

    labels = ["Male Participants", "Female Participants"]
    values = [male, female]
    layout = go.Layout(title="Total Ratio Of Participants")
    fig2 = go.Figure(data=[go.Pie(labels=labels, values=values, hole=0.5)],
                     layout=layout)
    st.plotly_chart(fig2)

# Create the option to display information about the
# yearly total of participants
if st.sidebar.checkbox("Participants: Yearly Total"):
    df["Games"] = df["Games"].fillna("0")
    df = pd.DataFrame(df)
    games = df["Games"].value_counts()

    trace = go.Bar(
        x=games.index,
        y=games.values,
        marker=dict(color=games.values, colorscale="Plotly3", showscale=True),
    )
コード例 #19
0
# EDA
percentual_sucess = round(df["state"].value_counts() / len(df["state"]) * 100,
                          2)

print("State Percent in %: ")
print(percentual_sucess)

# In[15]:

state = round(df["state"].value_counts() / len(df["state"]) * 100, 2)

labels = list(state.index)
values = list(state.values)

trace1 = go.Pie(labels=labels, values=values, marker=dict(colors=['red']))

layout = go.Layout(title='State Distribution', legend=dict(orientation="h"))

fig = go.Figure(data=[trace1], layout=layout)
iplot(fig)

# In[16]:

# Only consider failed or successful projects
# Exclude suspended, cancelled, and other misc states
df = df[(df['state'] == "failed") | (df['state'] == "successful")]

# In[17]:

state = round(df["state"].value_counts() / len(df["state"]) * 100, 2)
コード例 #20
0
##auth = dash_auth.BasicAuth(app,USERNAME_PASSWORD_PAIRS)
server = app.server

colors = {
    'chartbackground': '#ffffff',
    'background':'#EEF1F6',
    'text': '#000000'
}

piecolours=['#7BA3B7','#6C8FA0','#5C7A89','#4D6672','#3D525B','#2E3D45','1F292E','0F1417']

graph1 = [
    dcc.Graph(
        id='piechart',
        figure={
        'data': [go.Pie(labels=labels, values=sizes,
                        marker={'colors': ['#C0D2D8','#425772']}, textinfo='label')],
        'layout': go.Layout(legend={'x': 1, 'y': 0.7}, 
                            plot_bgcolor = colors['background'], paper_bgcolor = colors['chartbackground'],
                            title='<b>Total Messages Per User</b>')
        }
    ),
]

graph2 = [
    dcc.Graph(
        id='linegraph',
        figure={
            'data': [
                {'x': data0['date'], 'y': data0['jodi_count'], 'type': 'line', 'name': 'Jodi'},
                {'x': data0['date'], 'y': data0['richard_count'], 'type': 'line', 'name': 'Richard'},
            ],
コード例 #21
0
def update_pie_chart(sentiment_term):
    # get data from cache

    c = conn.cursor()
    import numpy as np

    '''df = pd.read_sql(
        "SELECT COUNT(*)(sentiment) FROM sentiment WHERE sentiment BETWEEN 0.000001 and 1 and country LIKE ? ORDER BY unix DESC LIMIT 1000 ;",
        conn, params=('%' + sentiment_term + '%',))'''

    # df = pd.read_sql("SELECT *(sentiment) FROM sentiment WHERE sentiment BETWEEN 0.000001 and 1 ;",conn)
    df = pd.read_sql(
        "SELECT COUNT(*)FROM sentiment WHERE sentiment BETWEEN 0.000001 and 1 and country LIKE ? ORDER BY unix DESC LIMIT 1000 ;",
        conn, params=('%' + sentiment_term + '%',))
    df2 = pd.read_sql(
        "SELECT COUNT(sentiment) FROM sentiment WHERE sentiment BETWEEN -1 and -0.0001 and country LIKE ? ORDER BY unix DESC LIMIT 1000 ;",
        conn, params=('%' + sentiment_term + '%',))
    df3 = pd.read_sql(
        "SELECT COUNT(sentiment) FROM sentiment WHERE sentiment =0 and country LIKE ? ORDER BY unix DESC LIMIT 1000 ;",
        conn, params=('%' + sentiment_term + '%',))
    # print(df2)

    '''print(df.dtypes)

    df_value=df.values
    x = df_value.astype(float)
    print('df.dtypes')
    print('x=',x)
    '''

    df_value = df.values
    x = df_value.astype(float)

    x = x.astype(int)

    df_value2 = df2.values
    y = df_value2.astype(float)

    y = y.astype(int)

    df_value3 = df3.values
    q = df_value3.astype(float)

    q = q.astype(int)
    # print(df)
    '''print(df2.values)
    x=df.values
    y=df.values

    print(x)
    print(y)
    '''
    import plotly.graph_objects as go

    labels =['Positive','Negative','natural']
    values = [int(x), int(y),int(q)]

    # fig = go.Figure(data=[go.Pie(labels=labels, values=values)])


    colors = ['#007F25', '#800000']

    trace = go.Pie(labels=labels, values=values,
                   hoverinfo='label+percent', textinfo='value',
                   textfont=dict(size=20, color=app_colors['text']),
                   marker=dict(colors=colors,
                               line=dict(color=app_colors['background'], width=2)))

    return {"data": [trace],
            'layout': go.Layout(
        title='Positive vs Negative sentiment for "{}" (longer-term)'.format(sentiment_term),
        font={'color': app_colors['text']},
        plot_bgcolor=app_colors['background'],
        paper_bgcolor=app_colors['background'],
        showlegend=True),}
コード例 #22
0
def write_html_tol(fpath, df_sell, max_huice):
    if len(df_sell) == 0:
        return
    m_data = df_sell[len(df_sell) - 1]
    datetime_x = [d['datetime'] for d in df_sell]
    datediff = relativedelta(m_data['datetime'], df_sell[0]['datetime'])
    datediff = "历经{}年{}个月{}天".format(datediff.years, datediff.months,
                                     datediff.days)
    labels = ["盈利", "亏损", "持平"]
    trade_num = m_data['ex_buy_count']
    trade_avg_ex = m_data['ex_zdf_count'] / trade_num
    trade_days = len(df_sell)
    trade_avg_day = m_data['day_sj_zdf_count'] / trade_days
    trade_tol_yl = m_data['zyk']
    trade_ex_sz = m_data['ex_sz_count']
    trade_ex_xd = m_data['ex_xd_count']
    trade_day_sz = m_data['day_sz']
    trade_day_xd = m_data['day_xd']
    fig = make_subplots(
        rows=3,
        cols=2,
        row_heights=[0.5, 0.3, 0.2],
        shared_xaxes=True,
        vertical_spacing=0.1,
        specs=[
            [{
                'type': 'xy',
                'colspan': 2
            }, None],
            [{
                'type': 'xy',
                'colspan': 2
            }, None],
            [{
                'type': 'domain'
            }, {
                'type': 'domain'
            }],
        ],
        subplot_titles=[
            '收益({:.2f}%)'.format(trade_tol_yl),
            '每日明细({})'.format(datediff),
            '次数({}) 平均涨幅 {:.2f}%'.format(trade_num, trade_avg_ex),
            '天数({}) 平均涨幅 {:.2f}%'.format(trade_days, trade_avg_day),
        ])
    fig.add_trace(
        go.Scatter(x=datetime_x,
                   y=[d['zyk'] for d in df_sell],
                   mode='lines+markers',
                   name="收益"), 1, 1)
    fig.add_trace(
        go.Scatter(x=datetime_x,
                   y=[d['day_sj_zdf_count'] for d in df_sell],
                   mode='markers',
                   name="每日明细"), 2, 1)
    fig.add_trace(
        go.Pie(labels=labels,
               values=[
                   trade_ex_sz, trade_ex_xd,
                   trade_num - (trade_ex_sz + trade_ex_xd)
               ],
               hole=.3,
               textinfo='label+percent+value',
               name='交易次数'), 3, 1)
    fig.add_trace(
        go.Pie(labels=labels,
               values=[
                   trade_day_sz, trade_day_xd,
                   trade_days - (trade_day_sz + trade_day_xd)
               ],
               hole=.3,
               textinfo='label+percent+value',
               name='交易天数'), 3, 2)
    fig.update_layout(showlegend=False,
                      height=1000,
                      title_text='最大回测:{}  夏普率:{}  年华收益:{}  '.format(
                          max_huice, 0, 0))
    fig.update_yaxes(zeroline=True, zerolinewidth=2, zerolinecolor='LightPink')
    fig.write_html(fpath, full_html=False)
コード例 #23
0
ファイル: app.py プロジェクト: davisobatista/plotly_Imagens
def update_heatmap_confidence(n, current_time, footage, threshold):
    layout = go.Layout(
        showlegend=False,
        paper_bgcolor="rgb(249,249,249)",
        plot_bgcolor="rgb(249,249,249)",
        autosize=False,
        margin=dict(l=10, r=10, b=20, t=20, pad=4),
    )

    if current_time is not None:
        current_frame = round(current_time * FRAMERATE)

        if n > 0 and current_frame > 0:
            # Load variables from the data dictionary
            video_info_df = data_dict[footage]["video_info_df"]
            classes_padded = data_dict[footage]["classes_padded"]
            root_round = data_dict[footage]["root_round"]
            classes_matrix = data_dict[footage]["classes_matrix"]

            # Select the subset of the dataset that correspond to the current frame
            frame_df = video_info_df[video_info_df["frame"] == current_frame]

            # Select only the frames above the threshold
            threshold_dec = threshold / 100
            frame_df = frame_df[frame_df["score"] > threshold_dec]

            # Remove duplicate, keep the top result
            frame_no_dup = frame_df[["class_str", "score"]].drop_duplicates("class_str")
            frame_no_dup.set_index("class_str", inplace=True)

            # The list of scores
            score_list = []
            for el in classes_padded:
                if el in frame_no_dup.index.values:
                    score_list.append(frame_no_dup.loc[el][0])
                else:
                    score_list.append(0)

            # Generate the score matrix, and flip it for visual
            score_matrix = np.reshape(score_list, (-1, int(root_round)))
            score_matrix = np.flip(score_matrix, axis=0)

            # We set the color scale to white if there's nothing in the frame_no_dup
            if frame_no_dup.shape != (0, 1):
                colorscale = [[0, "#f9f9f9"], [1, "#fa4f56"]]
            else:
                colorscale = [[0, "#f9f9f9"], [1, "#f9f9f9"]]

            hover_text = [f"{score * 100:.2f}% confidence" for score in score_list]
            hover_text = np.reshape(hover_text, (-1, int(root_round)))
            hover_text = np.flip(hover_text, axis=0)

            # Add linebreak for multi-word annotation
            classes_matrix = classes_matrix.astype(dtype="|U40")

            for index, row in enumerate(classes_matrix):
                row = list(map(lambda x: "<br>".join(x.split()), row))
                classes_matrix[index] = row

            # Set up annotation text
            annotation = []
            for y_cord in range(int(root_round)):
                for x_cord in range(int(root_round)):
                    annotation_dict = dict(
                        showarrow=False,
                        text=classes_matrix[y_cord][x_cord],
                        xref="x",
                        yref="y",
                        x=x_cord,
                        y=y_cord,
                    )
                    if score_matrix[y_cord][x_cord] > 0:
                        annotation_dict["font"] = {"color": "#F9F9F9", "size": "11"}
                    else:
                        annotation_dict["font"] = {"color": "#606060", "size": "11"}
                    annotation.append(annotation_dict)

            # Generate heatmap figure

            figure = {
                "data": [
                    {
                        "colorscale": colorscale,
                        "showscale": False,
                        "hoverinfo": "text",
                        "text": hover_text,
                        "type": "heatmap",
                        "zmin": 0,
                        "zmax": 1,
                        "xgap": 1,
                        "ygap": 1,
                        "z": score_matrix,
                    }
                ],
                "layout": {
                    "showlegend": False,
                    "autosize": False,
                    "paper_bgcolor": "rgb(249,249,249)",
                    "plot_bgcolor": "rgb(249,249,249)",
                    "margin": {"l": 10, "r": 10, "b": 20, "t": 20, "pad": 2},
                    "annotations": annotation,
                    "xaxis": {
                        "showticklabels": False,
                        "showgrid": False,
                        "showline": False,
                        "zeroline": False,
                        "side": "top",
                        "ticks": "",
                    },
                    "yaxis": {
                        "showticklabels": False,
                        "showgrid": False,
                        "showline": False,
                        "zeroline": False,
                        "side": "left",
                        "ticks": "",
                    },
                },
            }

            return figure

    # Returns empty figure
    return go.Figure(data=[go.Pie()], layout=layout)
コード例 #24
0
ファイル: budget.py プロジェクト: amalerba-stern/freestyle
pie_data = [{
    "category": "housing",
    "spend_pct": spend_housing
}, {
    "category": "food",
    "spend_pct": spend_food
}, {
    "category": "personal",
    "spend_pct": spend_personal
}, {
    "category": "transportation",
    "spend_pct": spend_transportation
}, {
    "category": "other",
    "spend_pct": spend_other
}]

print("----------------")
print("GENERATING PIE CHART...")

labels = [pie_data["category"] for pie_data in pie_data]
values = [pie_data["spend_pct"] for pie_data in pie_data]
trace = go.Pie(labels=labels, values=values)  #, title="Spending by Category")
layout_pie = go.Layout(title="Spending by Category")
plotly.offline.plot({
    "data": trace,
    "layout": layout_pie
},
                    filename="spending_by_category.html",
                    auto_open=True)
コード例 #25
0
plt.show()

#Method2
import matplotlib.pyplot as plt
 
labels = ['Cookies', 'Jellybean', 'Milkshake', 'Cheesecake']
sizes = [38.4, 40.6, 20.7, 10.3]
colors = ['yellowgreen', 'gold', 'lightskyblue', 'lightcoral']
patches, texts = plt.pie(sizes, colors=colors, shadow=True, startangle=90)
plt.legend(patches, labels, loc="best")
plt.axis('equal')
plt.tight_layout()
plt.show()



#Method2
import plotly
plotly.tools.set_credentials_file(username='******', api_key='0zZ5FLEa1sM0EfqsMK9R')

import plotly as py1
import plotly.plotly as py
import plotly.graph_objs as go

labels = ['Oxygen','Hydrogen','Carbon_Dioxide','Nitrogen']
values = [4500,2500,1053,500]

trace = go.Pie(labels=labels, values=values)

py.iplot([trace], filename='basic_pie_chart')
コード例 #26
0
ファイル: server.py プロジェクト: netzkontrast/prometheus_ml
def update_charts(goodness, skew, threshold):
    df = generate_roc_curve_df(goodness, skew)

    hist_kwargs = dict(opacity=0.75,
                       autobinx=False,
                       xbins=dict(start=-10.0, end=10, size=0.5))

    return html.Div([
        html.Div([
            dcc.Graph(id='classes',
                      figure=dict(data=[
                          go.Histogram(x=df[df.pos == 1].score, **hist_kwargs),
                          go.Histogram(x=df[df.neg == 1].score, **hist_kwargs)
                      ],
                                  layout=go.Layout(
                                      barmode='overlay',
                                      xaxis=dict(range=[-10, 10]),
                                      yaxis=dict(range=[0, 200]),
                                      width=400,
                                      height=400,
                                      autosize=False,
                                      legend=dict(orientation="h"),
                                      margin=go.Margin(l=40, t=40)))),
            dcc.Graph(id='rates',
                      figure=dict(data=[
                          go.Scatter(x=df.score, y=df.tpr),
                          go.Scatter(x=df.score, y=df.fpr),
                      ],
                                  layout=go.Layout(
                                      xaxis=dict(range=[-10, 10],
                                                 zeroline=False),
                                      yaxis=dict(range=[0, 1]),
                                      width=400,
                                      height=400,
                                      autosize=False,
                                      legend=dict(orientation="h"),
                                      margin=go.Margin(l=40, t=40)))),
        ],
                 style={'columnCount': 2}),
        html.Div([
            dcc.Graph(id='roc',
                      figure=dict(data=[go.Scatter(x=df.fpr, y=df.tpr)],
                                  layout=go.Layout(
                                      xaxis=dict(range=[0, 1]),
                                      yaxis=dict(range=[0, 1]),
                                      width=400,
                                      height=400,
                                      autosize=False,
                                      legend=dict(orientation="h"),
                                      margin=go.Margin(l=40, t=40)))),
            dcc.Graph(
                id='confusion',
                figure=dict(data=[
                    go.Pie(labels=['tp', 'fp', 'tn', 'fn'],
                           values=df.iloc[threshold][['tp', 'fp', 'tn', 'fn']],
                           sort=False)
                ],
                            layout=go.Layout(width=400,
                                             height=400,
                                             autosize=False,
                                             legend=dict(orientation="h"),
                                             margin=go.Margin(l=40, t=40)))),
        ],
                 style={'columnCount': 2})
    ],
                    style={'width': "600px"})
コード例 #27
0
ファイル: app.py プロジェクト: miguelramos0703/DV_project
def plots_actualize(df2):
    fig_map = go.Figure(data=go.Scattermapbox(lat=df2["latitude"],
                                              lon=df2["longitude"],
                                              mode="markers",
                                              marker=dict(color="#5A6FF9")),
                        layout=go.Layout(autosize=True,
                                         margin=go.layout.Margin(l=0,
                                                                 r=0,
                                                                 t=0,
                                                                 b=0),
                                         showlegend=False,
                                         mapbox=dict(
                                             accesstoken=mapbox_access_token,
                                             style="dark",
                                             center={
                                                 'lat': 39,
                                                 'lon': -9.2
                                             },
                                             zoom=8.5,
                                         )))

    pie_colors = ["#636EFA", "#4296f5", "#42ddf5"]
    unique_rooms = list(df2.room_type.unique())
    if len(unique_rooms) == 1:
        if unique_rooms[0] == 'Private room':
            pie_colors = ["#4296f5"]
        elif unique_rooms[0] == 'Shared room':
            pie_colors = ["#42ddf5"]

    fig_pie = go.Figure(data=go.Pie(
        labels=df2['room_type'].value_counts().index,
        values=df2['room_type'].value_counts().values,
        textinfo='text+value+percent',
        text=df2['room_type'].value_counts().index,
        hoverinfo='label',
        showlegend=False,
        textfont=dict(color="white"),
        marker=(dict(colors=pie_colors, line=dict(color="white", width=0.5)))),
                        layout=go.Layout(
                            paper_bgcolor='rgba(0,0,0,0)',
                            plot_bgcolor='rgba(0,0,0,0)',
                            margin=go.layout.Margin(l=0, r=0, t=0, b=0),
                        ))

    fig_bar = go.Figure(data=go.Bar(
        x=df2['ordinal_rating'].value_counts().values,
        y=df2['ordinal_rating'].value_counts().index,
        orientation='h',
        marker=dict(line=dict(color="white"))),
                        layout=go.Layout(
                            paper_bgcolor='rgba(0,0,0,0)',
                            plot_bgcolor='rgba(0,0,0,0)',
                            margin=go.layout.Margin(l=0, r=0, t=0, b=0),
                            clickmode='event+select',
                            font=dict(color="white"),
                            xaxis_title='Number of Listings',
                        ))

    fig_hist = go.Figure(data=go.Histogram(
        x=df2['price'],
        histnorm="",
        xbins=dict(size=30, end=800),
        marker=dict(line=dict(color="white", width=0.25))),
                         layout=go.Layout(margin=go.layout.Margin(l=0,
                                                                  r=0,
                                                                  t=0,
                                                                  b=0),
                                          clickmode='event+select',
                                          paper_bgcolor='rgba(0,0,0,0)',
                                          plot_bgcolor='rgba(0,0,0,0)',
                                          xaxis_title='Price (€)',
                                          yaxis_title='Absolute frequencies',
                                          showlegend=False,
                                          font=dict(color="white")))

    return (fig_map, fig_pie, fig_bar, fig_hist)
コード例 #28
0
def update_graph(hotel_group_id, hotel_id, hotel__city, start_date, end_date,
                 **kwargs):

    # get metadata for current user
    current_user = kwargs['user']
    user_id = current_user.pk
    user_metadata = UserMetadata.objects.get(user_id=user_id)

    hotel_group_filter = {} if hotel_group_id == None else {
        "hotel_group_id": hotel_group_id
    }
    hotel_filter = {} if hotel_id == None else {"hotel_id": hotel_id}
    hotel__city_filter = {} if hotel__city == None else {
        "hotel__city": hotel__city
    }
    booking_start_date_filter = {} if start_date == None else {
        "start_date__gte": dt.strptime(start_date.split(' ')[0], '%Y-%m-%d')
    }
    booking_end_date_filter = {} if end_date == None else {
        "end_date__lte": dt.strptime(end_date.split(' ')[0], '%Y-%m-%d')
    }

    # if group or hotel then apply filter
    if current_user.groups.filter(name='Hotel Group Administrators').exists():
        hotel_group_id = user_metadata.hotel_group_id
        # bookings = Booking.objects.filter(hotel_group_id=hotel_group_id)
        bookings = Booking.objects.filter(hotel_group_id=hotel_group_id).filter(**hotel__city_filter).filter(**hotel_filter).filter(**booking_start_date_filter)\
                    .filter(**booking_end_date_filter)\
                    .values('start_date') \
                    .annotate(total=Count('hotel_id'))
    elif current_user.groups.filter(name='Hotel Administrators').exists():
        hotel_id = user_metadata.hotel_id
        bookings = Booking.objects.filter(hotel_id=hotel_id).filter(**booking_start_date_filter).filter(**booking_end_date_filter)\
                    .values('start_date') \
                    .annotate(total=Count('hotel_id'))
    else:
        bookings = Booking.objects.filter(**hotel_group_filter).filter(**hotel__city_filter).filter(**hotel_filter).filter(**booking_start_date_filter)\
                    .filter(**booking_end_date_filter)\
                    .values('start_date') \
                    .annotate(total=Count('hotel_id'))

    if len(bookings) == 0:
        return {
            "data": [go.Pie(labels=[], values=[], textinfo='label')],
            "layout":
            go.Layout({
                "annotations": [{
                    "text": "No matching data found",
                    "showarrow": False
                }]
            })
        }
    else:
        #values=[booking['total'] for booking in list(bookings)]
        df = pd.DataFrame(list(bookings))
        #labels=[booking['start_date'] for booking in list(bookings)]

        return {
            "data": [go.Scatter(x=df.start_date, y=df['total'])],
            "layout":
            go.Layout(
                margin=dict(t=20, l=50, r=50, pad=0),
                autosize=True,
                width=350,
            )
        }
コード例 #29
0
    movies.movie_name,
    COUNT(watched_movies.review_id_fk)
FROM
    watched_movies INNER JOIN movies ON watched_movies.movie_id_fk = movies.movie_id
GROUP BY
    movies.movie_name
""")

movies = []
movie_reviews_count = []

for row in cursor.fetchall():
    movies.append(row[0])
    movie_reviews_count.append(row[1])

pie = go.Pie(labels=movies, values=movie_reviews_count)
movies_reviews_proportion_url = py.plot([pie], filename='reviews-count')
""" create plot 3  """

cursor.execute("""
SELECT
    reviews.review_date, COUNT(DISTINCT profiles.profile_id)
FROM
    profiles INNER JOIN watched_movies ON profiles.profile_id = watched_movies.profile_id_fk
    INNER JOIN reviews ON reviews.review_id = watched_movies.review_id_fk 
GROUP BY
    reviews.review_date
ORDER BY
    reviews.review_date
""")
コード例 #30
0
    df_info = pd.concat(_temp,axis=1).T
    df_info.index.name = '指标'
    df_info = df_info.round(decimals=3)

    import plotly.offline as pyof
    from plotly import figure_factory as ff
    table = ff.create_table(df_info,index=True, index_title='指标')
    pyof.plot(table, filename='产品组合信息表.html')


    '''画饼图'''
    import plotly.graph_objs as go

    labels=df_info.columns[:-1]
    values=w
    trace=go.Pie(labels=labels,values=values,text='哈哈')
    layout = dict(title = '产品组合成分图')
    fig = dict(data=[trace],layout=layout)
    pyof.plot(fig,filename='组合成分图.html')


    '''画产品对比图'''
    import tushare as ts
    data_hs300 = ts.get_hist_data('hs300')
    data_hs300 = data_hs300.rename_axis(lambda x:pd.to_datetime(x))
    df_contra = pd.concat([data_hs300.close,df['组合']],axis=1,join='inner')
    df_contra = df_contra / df_contra.iloc[0,:]
    df_contra.rename(columns={'close':'沪深300'},inplace=True)


    import plotly.graph_objs as go