개발/프로젝트

웹대시보드 프로젝트 - 6일차 (EC2에서 에러 해결하기)

웅'jk 2022. 12. 23. 14:51

5일차 까지 만든 프로젝트결과물에서 날짜 선택을 데이터의 첫 날짜 부터 마지막 날짜 까지로 선택하게 만들고

홈에서는 어떤 데이터를 이용하였는지 간략하게 적었으며, 사이드바에서 이미지 url에 오류가 있어 수정하였습니다.

 

그리고  EC2 서버에 업로드 하여 실행을 하였으나 , 실행되지 않고 서버가 다운되는 현상이 발견되었습니다.

 

원인을 분석하던 도중 games_detail의 데이터와 teams를 merge 함수를 이용해 합쳤을때 오류가 나는 것을 확인하였습니다.

 

EC2 프리티어버전에서는 용량이 크면 서버가 다운 될 수도 있다는 말에 games_detail에 데이터를 절반으로 줄여 다시 실행하니 작동이 되었습니다.

 

따라서 games_detail 절반값인 games_detail_half.csv 을 만들어 진행하였습니다.

 

1. games_details_half.csv 생성

df_games_detail.head(323442).to_csv('data/games_details_half.csv')

 

2. data_init 수정

import pandas as pd

df_teams = pd.read_csv('data/teams.csv')
df_games = pd.read_csv('data/games.csv')
df_players = pd.read_csv('data/players.csv')
# 기존 데이터 오류로 half 만 가져왔다.
df_games_detail = pd.read_csv('data/games_details_half.csv',low_memory = False)

df_teams = df_teams.loc[:,['TEAM_ID','ABBREVIATION','YEARFOUNDED','CITY','ARENA']]
df_games = df_games.loc[:,['GAME_DATE_EST','GAME_ID','HOME_TEAM_ID','PTS_home','AST_home','REB_home','TEAM_ID_away','PTS_away','AST_away','REB_away','HOME_TEAM_WINS']]
# 문제 없는 데이터프레임
df_games_detail_1 = df_games_detail.loc[:,:'START_POSITION']
# 문제 있는 데이터프레임 짜른 뒤 수정
df_games_detail_2 = df_games_detail.loc[:,'COMMENT':].shift(-1,axis= 1)
# 짜른 두 코드를 합쳤다.
df_games_detail = pd.concat([df_games_detail_1,df_games_detail_2],axis=1)
df_games_detail = df_games_detail.loc[:,['GAME_ID', 'TEAM_ID','PLAYER_ID','PLAYER_NAME','START_POSITION',
                       'COMMENT','MIN', 'FG_PCT', 'FG3_PCT', 
                       'DREB', 'REB', 'AST', 'STL', 'BLK','TO']]
rename ={ 'GAME_DATE_EST' : '경기날짜' ,'GAME_ID':'경기ID', 'HOME_TEAM_ID':'홈팀ID','PTS_home':'홈팀점수','AST_home':'홈팀어시','REB_home':'홈팀리바운드','TEAM_ID_away':'어웨이팀ID','PTS_away':'어웨이팀점수','AST_away':'어웨이팀어시','REB_away':'어웨이팀리바운드','HOME_TEAM_WINS':'홈팀승리여부'  }
df_games = df_games.rename(columns=rename)
df_games=df_games.fillna(0)

rename_detail = { 'GAME_ID':'경기ID','TEAM_ID':'팀ID','PLAYER_ID':'선수ID','PLAYER_NAME':'선수명',
                 'START_POSITION':'포지션',
 'COMMENT':'출전시간','MIN':'2점슛', 'FG_PCT':'3점슛', 'FG3_PCT':'자유투',
 'DREB':'리바운드','REB':'어시스트','AST':'가로채기','STL':'블락','BLK':'턴오버','TO':'파울'}
df_games_detail = df_games_detail.rename(columns=rename_detail)
df_games_detail = df_games_detail.fillna(0)
    
rename_playes = { 'PLAYER_NAME':'선수명','TEAM_ID':'팀ID','PLAYER_ID':'선수ID','SEASON':'시즌' }
df_players=df_players.rename(columns=rename_playes)
    
rename_team = {'TEAM_ID':'팀ID','ABBREVIATION':'팀약어','YEARFOUNDED':'팀창설해',
                'CITY':'연고지','ARENA':'홈구장'}
df_teams = df_teams.rename(columns=rename_team)

# 가공을 편하게 하기위해 df_games에 홈팀명,어웨이팀명 추가
df_teams_home = df_teams.rename(columns={'팀ID':'홈팀ID'})
new_data = pd.merge(df_games,df_teams_home, on = '홈팀ID').iloc[:,:-3].rename(columns={'팀약어':'홈팀'})
df_teams_away = df_teams.rename(columns={'팀ID':'어웨이팀ID'})
df_games=pd.merge(new_data,df_teams_away,on = '어웨이팀ID').iloc[:,:-3].rename(columns={'팀약어':'어웨이팀'})

# 가공을 편하게 하기 위해 df_platers에 팀명 추가
df_players=pd.merge(df_players,df_teams,on='팀ID').iloc[:,0:4+1]

# 가공을 편하게 하기 위해 df_games_detail 에 날짜 추가
df_games_detail=pd.merge(df_games_detail,df_games,on='경기ID').loc[:,:'경기날짜'].sort_values('경기날짜',ascending=False)

# 가공을 편하게 하기위해 df_games_detail에 약어 추가
df_games_detail = pd.merge(df_games_detail,df_teams,on='팀ID').iloc[:,:-3]

 

2. home.py 수정

import streamlit as st
import data_init
def home() :
    st.title('NBA 데이터 센터에 오신걸 환영합니다.')
    image_url = 'https://mblogthumb-phinf.pstatic.net/MjAxOTA2MTNfMjkw/MDAxNTYwMzkyODk3MDQ0._UQzxFUpS-lLFTg5FX4nsP6o9WxKBVB1IlEAoo3Scz8g.50FBo4vY3wwoXSPk2-Pzt5mP_mM_gx8n2HsbZ7ZR7Lkg.PNG.swmh69/nba_%EB%A1%9C%EA%B3%A0.png?type=w800'
    st.image(image_url)
    st.subheader('')

    st.subheader('프로젝트 안내사항')
    st.text('kaggle 에 NBA 데이터를 이용하였습니다.')
    st.write("[kaggle nba data 바로가기](https://www.kaggle.com/datasets/nathanlauga/nba-games?resource=download&select=teams.csv)")
    st.text('사용한 데이터는 다음과 같습니다.')
    st.text('teams')
    st.dataframe(data_init.df_teams.head())
    st.text('players')
    st.dataframe(data_init.df_players.head())
    st.text('games')
    st.dataframe(data_init.df_games.head())
    st.text('games_detail')
    st.dataframe(data_init.df_games_detail.head())
    st.error('games_details 에 데이터용량이 EC2 서버에서 이용하기에는 너무 커 절반만 사용하였습니다.')

 

3. player.py 수정

import streamlit as st
import data_init
import pandas as pd
import matplotlib.pyplot as plt
import plotly.express as px
import platform
from matplotlib import font_manager, rc
import numpy as np
import plotly.graph_objects as go
from datetime import datetime
def player(player_name) :
   
    plt.rcParams['axes.unicode_minus'] = False
    if platform.system() == 'Linux':
        rc('font', family='NanumGothic')
    elif platform.system() == 'Windows':
        path = "c:/Windows/Fonts/malgun.ttf"
        font_name = font_manager.FontProperties(fname=path).get_name()
        rc('font', family=font_name)

    # 데이터를 읽어온다.
    # 선수 데이터
    df_players = data_init.df_players
    # 선수 스탯 데이터
    df_games_detail = data_init.df_games_detail
    # 팀정보
    df_team = data_init.df_teams
    # header
    st.header('선수 정보')
    # 선수명 확인
    player_list = df_players[df_players['선수명'].str.contains(player_name,case=False)]['선수명'].unique().tolist()
    
    if len(player_list) > 1 :
       
        st.error('중복되는 선수명을 가진 선수가 있습니다. 내역을 보시고 다시 입력해주세요.')
        player = pd.DataFrame(sorted(player_list),columns=['선수명'])
        st.dataframe(player)
    elif len(player_list) == 0 :
        st.error('등록된 선수가 없습니다. 다시 입력해주세요.')
        st.subheader('등록된 선수 목록')
        all_player_list = sorted(df_players['선수명'].unique())
        st.dataframe(pd.DataFrame({'선수명':all_player_list}))
    elif len(player_list) == 1 :
        player = player_list[0]
        # 플레이어 데이터 보여주기
        df_player = df_players[df_players['선수명'] == player]
        st.dataframe(df_player.iloc[:,[0,4,2,3]])

        # 스탯 조회하기
        # 선수 데이터 가져오기
        
        df_player_data = df_games_detail[df_games_detail['선수ID'] == df_player['선수ID'].unique()[0]].sort_values('경기날짜',ascending=False)
        
        # 1. 기간 선택하기
        st.subheader('선수 스탯 조회하기')
        if df_player_data.empty :
            st.error('해당 선수의 데이터가 없습니다.')
        else :
            radio_status = st.radio('검색',['날짜별','소속팀별'])
            if radio_status == '날짜별' :
                min_date = datetime.strptime(df_player_data['경기날짜'].tail(1).values[0],'%Y-%m-%d' )
                max_date = datetime.strptime(df_player_data['경기날짜'].head(1).values[0],'%Y-%m-%d' )
                start_date = st.date_input('시작 날짜',min_value=min_date,max_value=max_date,value=min_date)
                end_date = st.date_input('종료 날짜',min_value=min_date,max_value=max_date,value=max_date)
                start_date = start_date.strftime('%Y-%m-%d')
                end_date = end_date.strftime('%Y-%m-%d')
                
                if start_date > end_date :
                    st.error('시작 날짜를 종료 날짜보다 전으로 설정해주세요.')
                else :
                    if df_player_data['경기날짜'].values[0] < start_date :
                        st.error('경기정보가 없습니다.')
                    else :
                        df_player_data_set=df_player_data[( df_player_data['경기날짜'] >= start_date ) & (df_player_data['경기날짜'] <= end_date) ]
                        
                        multiselectbox_list = ['상세','평균','2점슛', '3점슛', '자유투', '리바운드', '어시스트', '가로채기', '블락', '턴오버', '파울']
                        selected_player_data = st.multiselect('데이터 선택',multiselectbox_list)
                        
                        # 그 경기 선수 평균 가져오기 
                        list_game_id = df_player_data_set['경기ID']
                        game_player_mean = df_games_detail[df_games_detail['경기ID'].isin(list_game_id)].groupby('경기날짜').mean().iloc[:,[0,3,4,5,6,7,8,9,10,11]]
                        game_player_mean=game_player_mean.sort_values('경기날짜',ascending=False)
                        # end

                        if '상세' in selected_player_data : 
                            st.subheader('상세정보')
                            st.dataframe(df_player_data_set.iloc[:,[15,16,3,4,5,6,7,8,9,10,11,12,13,14,]])
                        if '평균' in selected_player_data :    
                            st.subheader('평균')
                            fig = go.Figure([ go.Bar(x=['2점슛', '3점슛', '자유투', '리바운드', '어시스트', '가로채기', '블락', '턴오버', '파울'],
                                                    y = df_player_data_set.loc[:,['2점슛', '3점슛', '자유투', '리바운드', '어시스트', '가로채기', '블락', '턴오버', '파울']].mean()  ) ])
                            st.plotly_chart(fig)

                        
                        # 평균과 set 합치기
                        df_player_data_set = df_player_data_set.sort_values('경기날짜',ascending=False)
                        total_player_data = pd.merge(df_player_data_set,game_player_mean,on='경기ID')
                        rename_columns = { '2점슛_x' : '2점슛' , '3점슛_x' : '3점슛' , '자유투_x' :'자유투',
                                            '리바운드_x':'리바운드','어시스트_x':'어시스트', '가로채기_x' : '가로채기',
                                            '블락_x':'블락','턴오버_x':'턴오버','파울_x':'파울','2점슛_y':'경기평균2점',
                                            '3점슛_y':'경기평균3점','자유투_y':'경기평균자유투','리바운드_y':'경기평균리바운드',
                                            '어시스트_y':'경기평균어시스트','가로채기_y':'경기평균가로채기','블락_y':'경기평균블락',
                                            '턴오버_y':'경기평균턴오버','파울_y':'경기평균파울'}
                        total_player_data = total_player_data.rename(columns=rename_columns)
                        #수비,공격지표 설정
                        offense_data_date = total_player_data.loc[:,['경기날짜','2점슛','3점슛','리바운드','어시스트','자유투','경기평균2점','경기평균3점','경기평균자유투','경기평균리바운드', '경기평균어시스트']]
                        defense_data_date = total_player_data.loc[:,['경기날짜', '가로채기', '블락', '턴오버', '파울','경기평균가로채기', '경기평균블락','경기평균턴오버', '경기평균파울']]
                        if '2점슛' in selected_player_data :
                            
                            #2점슛
                            st.subheader('2점')
                            chart_offense_data_date_2_point = px.bar(offense_data_date,x='경기날짜',y=['2점슛','경기평균2점'] ,barmode='group')
                            st.plotly_chart(chart_offense_data_date_2_point)
                            st.info('자세히 보고싶은 부분을 좌클릭으로 영역 지정 해주세요.')
                        if '3점슛' in selected_player_data :    
                            # 3점슛
                            st.subheader('3점')
                            chart_offense_data_date_3_point = px.bar(offense_data_date,x='경기날짜',y=['3점슛','경기평균3점'] ,barmode='group')
                            st.plotly_chart(chart_offense_data_date_3_point)
                            st.info('자세히 보고싶은 부분을 좌클릭으로 영역 지정 해주세요.')
                        if '자유투' in selected_player_data :    
                            #자유투
                            st.subheader('자유투')
                            chart_offense_data_date_free_point = px.bar(offense_data_date,x='경기날짜',y=['자유투','경기평균자유투'] ,barmode='group')
                            st.plotly_chart(chart_offense_data_date_free_point)
                            st.info('자세히 보고싶은 부분을 좌클릭으로 영역 지정 해주세요.')
                        if '리바운드' in selected_player_data :    
                            #리바
                            st.subheader('리바운드')
                            chart_offense_data_date_re = px.bar(offense_data_date,x='경기날짜',y=['리바운드','경기평균리바운드'] ,barmode='group')
                            st.plotly_chart(chart_offense_data_date_re)
                            st.info('자세히 보고싶은 부분을 좌클릭으로 영역 지정 해주세요.')
                        if '어시스트' in selected_player_data :    
                            #어시
                            st.subheader('어시스트')
                            chart_offense_data_date_assist = px.bar(offense_data_date,x='경기날짜',y=['어시스트','경기평균어시스트'] ,barmode='group')
                            st.plotly_chart(chart_offense_data_date_assist)
                            st.info('자세히 보고싶은 부분을 좌클릭으로 영역 지정 해주세요.')

                        if '가로채기' in selected_player_data :
                            
                            #가로채기
                            st.subheader('가로채기')
                            chart_defense_data_date_st = px.bar(defense_data_date,x='경기날짜',y=['가로채기','경기평균가로채기'] ,barmode='group')
                            st.plotly_chart(chart_defense_data_date_st)
                            st.info('자세히 보고싶은 부분을 좌클릭으로 영역 지정 해주세요.')
                        if '블락' in selected_player_data :   
                            #블락
                            st.subheader('블락')
                            chart_defense_data_date_bk = px.bar(defense_data_date,x='경기날짜',y=['블락','경기평균블락'] ,barmode='group')
                            st.plotly_chart(chart_defense_data_date_bk)
                            st.info('자세히 보고싶은 부분을 좌클릭으로 영역 지정 해주세요.')
                        if '턴오버' in selected_player_data :       
                            #턴오버
                            st.subheader('턴오버')
                            chart_defense_data_date_to = px.bar(defense_data_date,x='경기날짜',y=['턴오버','경기평균턴오버'] ,barmode='group')
                            st.plotly_chart(chart_defense_data_date_to)
                            st.info('자세히 보고싶은 부분을 좌클릭으로 영역 지정 해주세요.')
                        if '파울' in selected_player_data :       
                            #파울
                            st.subheader('파울')
                            chart_defense_data_date_p = px.bar(defense_data_date,x='경기날짜',y=['파울','경기평균파울'] ,barmode='group')
                            st.plotly_chart(chart_defense_data_date_p)
                            st.info('자세히 보고싶은 부분을 좌클릭으로 영역 지정 해주세요.')
            
                
            elif radio_status =='소속팀별' :
                team_list = df_player_data['팀약어'].unique()
                choose_team =st.multiselect('팀선택',team_list)
                if len(choose_team) < 1 :
                    st.error('팀을 선택해주세요')
                else :
                    multiselectbox_list=st.multiselect('데이터 선택',['상세','평균','2점슛', '3점슛', '자유투', '리바운드', '어시스트', '가로채기', '블락', '턴오버', '파울'])

                    choose_team_player_data = df_player_data[df_player_data['팀약어'].isin(choose_team) ]
                    
                    # 그 경기 선수 평균 가져오기 
                    list_game_id = choose_team_player_data['경기ID']
                    game_player_mean = df_games_detail[df_games_detail['경기ID'].isin(list_game_id)].groupby('경기날짜').mean().iloc[:,[0,3,4,5,6,7,8,9,10,11]]
                    game_player_mean=game_player_mean.sort_values('경기날짜',ascending=False)
                    # end

                    #상세
                    if '상세' in multiselectbox_list : 
                        st.subheader('상세정보')
                        st.dataframe(choose_team_player_data.iloc[:,[15,16,3,4,5,6,7,8,9,10,11,12,13,14,]])
                    if '평균' in multiselectbox_list :    
                        st.subheader('평균')
                        fig = go.Figure([ go.Bar(x=['2점슛', '3점슛', '자유투', '리바운드', '어시스트', '가로채기', '블락', '턴오버', '파울'],
                                                    y = choose_team_player_data.loc[:,['2점슛', '3점슛', '자유투', '리바운드', '어시스트', '가로채기', '블락', '턴오버', '파울']].mean()  ) ])
                        st.plotly_chart(fig)

                    choose_team_player_data = choose_team_player_data.sort_values('경기날짜',ascending=False)
                    
                    total_player_data = pd.merge(choose_team_player_data,game_player_mean,on='경기ID')
                    rename_columns = { '2점슛_x' : '2점슛' , '3점슛_x' : '3점슛' , '자유투_x' :'자유투',
                                        '리바운드_x':'리바운드','어시스트_x':'어시스트', '가로채기_x' : '가로채기',
                                        '블락_x':'블락','턴오버_x':'턴오버','파울_x':'파울','2점슛_y':'경기평균2점',
                                        '3점슛_y':'경기평균3점','자유투_y':'경기평균자유투','리바운드_y':'경기평균리바운드',
                                        '어시스트_y':'경기평균어시스트','가로채기_y':'경기평균가로채기','블락_y':'경기평균블락',
                                        '턴오버_y':'경기평균턴오버','파울_y':'경기평균파울'}
                    total_player_data = total_player_data.rename(columns=rename_columns)

                    #수비,공격지표 설정
                    offense_data_date = total_player_data.loc[:,['경기날짜','2점슛','3점슛','리바운드','어시스트','자유투','경기평균2점','경기평균3점','경기평균자유투','경기평균리바운드', '경기평균어시스트']]
                    defense_data_date = total_player_data.loc[:,['경기날짜', '가로채기', '블락', '턴오버', '파울','경기평균가로채기', '경기평균블락','경기평균턴오버', '경기평균파울']]

                    if '2점슛' in multiselectbox_list :
                            
                        #2점슛
                        st.subheader('2점')
                        slider_2=st.slider('최근 2점 데이터 경기수를 지정해주세요.',min_value= 5 , max_value=int(offense_data_date.count()[0]) , value= 10)
                        chart_offense_data_date_2_point = px.bar(offense_data_date.head(slider_2),x=np.arange(offense_data_date.head(slider_2).count()[0]),y=['2점슛','경기평균2점'] ,barmode='group',labels={'x':'경기수'})
                        
                        st.plotly_chart(chart_offense_data_date_2_point)
                        st.info('자세히 보고싶은 부분을 좌클릭으로 영역 지정 해주세요.')
                    if '3점슛' in multiselectbox_list :    
                        # 3점슛
                        st.subheader('3점')
                        slider_3=st.slider('최근 3점 데이터 경기수를 지정해주세요.',min_value= 5 , max_value=int(offense_data_date.count()[0]) , value= 10)
                        chart_offense_data_date_3_point = px.bar(offense_data_date.head(slider_3),x=np.arange(offense_data_date.head(slider_3).count()[0]),y=['3점슛','경기평균3점'] ,barmode='group',labels={'x':'경기수'})
                        st.plotly_chart(chart_offense_data_date_3_point)
                        st.info('자세히 보고싶은 부분을 좌클릭으로 영역 지정 해주세요.')
                    if '자유투' in multiselectbox_list :    
                        #자유투
                        st.subheader('자유투')
                        slider_f=st.slider('최근 자유투 데이터 경기수를 지정해주세요.',min_value= 5 , max_value=int(offense_data_date.count()[0]) , value= 10)
                        chart_offense_data_date_free_point = px.bar(offense_data_date.head(slider_f),x=np.arange(offense_data_date.head(slider_f).count()[0]),y=['자유투','경기평균자유투'] ,barmode='group',labels={'x':'경기수'})
                        st.plotly_chart(chart_offense_data_date_free_point)
                        st.info('자세히 보고싶은 부분을 좌클릭으로 영역 지정 해주세요.')
                    if '리바운드' in multiselectbox_list :    
                            #리바
                        st.subheader('리바운드')
                        slider_r=st.slider('최근 리바운드 데이터 경기수를 지정해주세요.',min_value= 5 , max_value=int(offense_data_date.count()[0]) , value= 10)
                        chart_offense_data_date_re = px.bar(offense_data_date.head(slider_r),x=np.arange(offense_data_date.head(slider_r).count()[0]),y=['리바운드','경기평균리바운드'] ,barmode='group',labels={'x':'경기수'})
                        st.plotly_chart(chart_offense_data_date_re)
                        st.info('자세히 보고싶은 부분을 좌클릭으로 영역 지정 해주세요.')
                    if '어시스트' in multiselectbox_list :    
                        #어시
                        st.subheader('어시스트')
                        slider_r=st.slider('최근 어시 데이터 경기수를 지정해주세요.',min_value= 5 , max_value=int(offense_data_date.count()[0]) , value= 10)
                        chart_offense_data_date_assist = px.bar(offense_data_date.head(slider_r),x=np.arange(offense_data_date.head(slider_r).count()[0]),y=['어시스트','경기평균어시스트'] ,barmode='group',labels={'x':'경기수'})
                        st.plotly_chart(chart_offense_data_date_assist)
                        st.info('자세히 보고싶은 부분을 좌클릭으로 영역 지정 해주세요.')

                    if '가로채기' in multiselectbox_list :
                        
                        #가로채기
                        st.subheader('가로채기')
                        slider_s=st.slider('최근 가로채기 데이터 경기수를 지정해주세요.',min_value= 5 , max_value=int(offense_data_date.count()[0]) , value= 10)
                        chart_defense_data_date_st = px.bar(defense_data_date.head(slider_s),x=np.arange(offense_data_date.head(slider_s).count()[0]),y=['가로채기','경기평균가로채기'] ,barmode='group',labels={'x':'경기수'})
                        st.plotly_chart(chart_defense_data_date_st)
                        st.info('자세히 보고싶은 부분을 좌클릭으로 영역 지정 해주세요.')
                    if '블락' in multiselectbox_list :   
                        #블락
                        st.subheader('블락')
                        slider_b=st.slider('최근 블락 데이터 경기수를 지정해주세요.',min_value= 5 , max_value=int(offense_data_date.count()[0]) , value= 10)
                        chart_defense_data_date_bk = px.bar(defense_data_date.head(slider_b),x=np.arange(offense_data_date.head(slider_b).count()[0]),y=['블락','경기평균블락'] ,barmode='group',labels={'x':'경기수'})
                        st.plotly_chart(chart_defense_data_date_bk)
                        st.info('자세히 보고싶은 부분을 좌클릭으로 영역 지정 해주세요.')
                    if '턴오버' in multiselectbox_list :       
                        #턴오버
                        st.subheader('턴오버')
                        slider_t=st.slider('최근 턴오버 데이터 경기수를 지정해주세요.',min_value= 5 , max_value=int(offense_data_date.count()[0]) , value= 10)
                        chart_defense_data_date_to = px.bar(defense_data_date.head(slider_t),x=np.arange(offense_data_date.head(slider_t).count()[0]),y=['턴오버','경기평균턴오버'] ,barmode='group',labels={'x':'경기수'})
                        st.plotly_chart(chart_defense_data_date_to)
                        st.info('자세히 보고싶은 부분을 좌클릭으로 영역 지정 해주세요.')
                    if '파울' in multiselectbox_list :       
                        #파울
                        st.subheader('파울')
                        slider_p=st.slider('최근 파울 데이터 경기수를 지정해주세요.',min_value= 5 , max_value=int(offense_data_date.count()[0]) , value= 10)
                        chart_defense_data_date_p = px.bar(defense_data_date.head(slider_p),x=np.arange(offense_data_date.head(slider_p).count()[0]),y=['파울','경기평균파울'] ,barmode='group',labels={'x':'경기수'})
                        st.plotly_chart(chart_defense_data_date_p)
                        st.info('자세히 보고싶은 부분을 좌클릭으로 영역 지정 해주세요.')

 

4.team.py 수정

import streamlit as st
import pandas as pd
import team_url as tu
import data_init
import matplotlib.pyplot as plt
import numpy as np
import platform
from matplotlib import font_manager, rc
import plotly.express as px
from datetime import datetime

def team(team_name) :
    
    plt.rcParams['axes.unicode_minus'] = False
    if platform.system() == 'Linux':
        rc('font', family='NanumGothic')
    elif platform.system() == 'Windows':
        path = "c:/Windows/Fonts/malgun.ttf"
        font_name = font_manager.FontProperties(fname=path).get_name()
        rc('font', family=font_name)
    
    # 팀의 데이터를 읽어온다.
    df_teams = data_init.df_teams
    df_games = data_init.df_games
    df_games_detail = data_init.df_games_detail
    # 팀정보 헤더 지정
    st.header(team_name)
    # 팀의 맞는 이미지 생성
    st.subheader('로고')
    st.image(tu.team_url(team_name),width=250)
    # 사이드바에서 선택한 팀으로 정보
    st.subheader('정보')
    df_teams_info = df_teams.loc[df_teams['팀약어'] == team_name,'팀약어':]
    st.dataframe(df_teams_info)
    
    # 시즌별 성적보기
    st.header('일자별 성적보기')
    team_id = df_teams[df_teams['팀약어'] == team_name]['팀ID'].values[0]
    
    
    
    # 시작과 끝 종료날짜를 설정하여 데이터 가져오기
    min_date = datetime.strptime(df_games['경기날짜'].tail(1).values[0],'%Y-%m-%d' )
    max_date = datetime.strptime(df_games['경기날짜'].head(1).values[0],'%Y-%m-%d' )
    start_date = st.date_input('시작 날짜',min_value=min_date,max_value=max_date,value=min_date)
    end_date = st.date_input('종료 날짜',min_value=min_date,max_value=max_date,value=max_date)
    start_date = start_date.strftime('%Y-%m-%d')
    end_date = end_date.strftime('%Y-%m-%d')
    if start_date > end_date :
        st.error('시작 날짜를 종료 날짜보다 전으로 설정해주세요.')
    # 전적을 비교하기 위한 list 생성
    team_name_list = ['','ATL', 'BOS', 'NOP', 'CHI', 'DAL', 'DEN', 'HOU', 'LAC', 'LAL',
       'MIA', 'MIL', 'MIN', 'BKN', 'NYK', 'ORL', 'IND', 'PHI', 'PHX',
       'POR', 'SAC', 'SAS', 'OKC', 'TOR', 'UTA', 'MEM', 'WAS', 'DET',
       'CHA', 'CLE', 'GSW']
    if df_games['경기날짜'][0] < start_date :
           st.error('경기정보가 없습니다. 날짜를 조정해주세요. 가장 최근 데이터는 '+df_games['경기날짜'][0]+'입니다.')  
    else :   
        # 홈 / 어웨이 선택
        selected = st.selectbox('홈/어웨이 선택',['홈','어웨이'])
        list_selected_box = ['상세','득점','어시스트','리바운드','역대전적','선수 스탯']       
        if selected == '홈' : 
            # 홈성적
            st.subheader('홈 성적')
            home_multi = st.multiselect('데이터 선택',list_selected_box)
            
            df_games_home = df_games.loc[ (df_games['홈팀ID']==team_id) & (start_date<=df_games['경기날짜']) & (df_games['경기날짜']<=end_date),:]
            df_games_home = df_games_home.sort_values('경기날짜',ascending=False)    
            if '상세' in home_multi :
                st.subheader('상세')
                st.dataframe(df_games_home.iloc[:,[11,12,0,3,4,5,7,8,9]])
                st.info('상세정보 입니다.')
            if '득점' in home_multi :
                
                
                #득점 데이터
                st.subheader('득점')
                recently_game = st.slider('홈 경기 득점 경기 수',min_value=3,max_value=int(df_games_home['경기ID'].count()),value=7)
                recently_point_pig = px.bar(df_games_home.head(recently_game),x='경기날짜',y=['홈팀점수','어웨이팀점수'],barmode='group')
                st.plotly_chart(recently_point_pig)
                st.info('날짜별 팀의 득점 정보 입니다.')

            if '어시스트' in home_multi :
                #어시스트 데이터
                st.subheader('어시스트')
                recently_game = st.slider('홈 경기 어시스트 경기 수',min_value=3,max_value=int(df_games_home['경기ID'].count()),value=7)
                recently_assist_pig = px.bar(df_games_home.head(recently_game),x='경기날짜',y=['홈팀어시','어웨이팀어시'],barmode='group')
                st.plotly_chart(recently_assist_pig)
                st.info('날짜별 팀의 어시스트 정보 입니다.')
            if '리바운드' in home_multi :
                #리바운드 데이터
                st.subheader('리바운드')
                recently_game = st.slider('최근 경기 리바운드 경기 수',min_value=3,max_value=int(df_games_home['경기ID'].count()),value=7)
                recently_rebound_pig = px.bar(df_games_home.head(recently_game),x='경기날짜',y=['홈팀리바운드','어웨이팀리바운드'],barmode='group')
                st.plotly_chart(recently_rebound_pig)
                st.info('날짜별 팀의 리바운드 정보 입니다.')
                
            if '역대전적' in home_multi:
                st.subheader('역대 홈 전적비교')
                compare_home_team = st.selectbox('팀선택',team_name_list)
                
                if compare_home_team != '' and compare_home_team != team_name : 
                    compare_team_id_home = df_teams[df_teams['팀약어'] == compare_home_team]['팀ID'].values[0]
                    data_home = df_games[(df_games['홈팀ID'] ==team_id) & (df_games['어웨이팀ID'] ==compare_team_id_home)]
                    st.dataframe(data_home.iloc[:,[11,0,3,4,5,12,7,8,9,10]].sort_values('경기날짜',ascending=False))
                    
                    if data_home.empty == False :
                        data_home = data_home.iloc[:,1:10+1].mean()
                        data_home['어웨이승리'] = 1 - data_home['홈팀승리여부']
                        fig_home = plt.figure()
                        plt.subplot(2,2,1)
                        plt.pie(data_home[[9,10]],autopct='%.1f',startangle = 90)
                        plt.title('홈팀 승률')
                        plt.legend(['홈','어웨이'])
                        
                        plt.subplot(2,2,2)
                        plt.pie(data_home[[2,6]],autopct='%.1f',startangle=90)
                        plt.title('평균 득점')
                        plt.legend(['홈','어웨이'])

                        plt.subplot(2,2,3)
                        plt.pie(data_home[[3,7]],autopct='%.1f',startangle=90)
                        plt.title('평균 어시')
                        plt.legend(['홈','어웨이'])

                        plt.subplot(2,2,4)
                        plt.pie(data_home[[4,8]],autopct='%.1f',startangle=90)
                        plt.title('평균 리바운드')
                        plt.legend(['홈','어웨이'])
                        st.pyplot(fig_home)
                    else :
                        st.title('')
                elif compare_home_team == team_name :
                    st.error('같은 팀 입니다. 다른 팀을 선택해주세요.')
                else : 
                    st.error('팀을 선택해주세요')

                
            if '선수 스탯' in home_multi :
                st.subheader('홈경기 선수 스탯')
                home_game_id = df_games_home['경기ID']
                
                home_team_player_info = df_games_detail[(df_games_detail['경기ID'].isin(home_game_id)) & (df_games_detail['팀ID'] == team_id)].iloc[:,3:].groupby('선수명').mean()
                st.dataframe(home_team_player_info)
                st.info('선수의 자세한 스탯은 카테고리 - 선수 를 이용해주세요.')
            
            else :
                st.write('')

        elif selected =='어웨이' :

            st.subheader('어웨이 성적')
            away_multi = st.multiselect('데이터 선택',list_selected_box)
            
            df_games_away = df_games.loc[ (df_games['어웨이팀ID']==team_id) & (start_date<=df_games['경기날짜']) & (df_games['경기날짜']<=end_date),:]
            df_games_away = df_games_away.sort_values('경기날짜',ascending=False)  
            if '상세' in away_multi :
                st.subheader('상세')
                st.dataframe(df_games_away.iloc[:,[11,12,0,3,4,5,7,8,9]])
                st.info('상세정보 입니다.')
            if '득점' in away_multi :
                
                 #득점 데이터
                st.subheader('득점')
                recently_game = st.slider('어웨이 경기 득점 경기 수',min_value=3,max_value=int(df_games_away['경기ID'].count()),value=7)
                recently_point_pig = px.bar(df_games_away.head(recently_game),x='경기날짜',y=['홈팀점수','어웨이팀점수'],barmode='group')
                st.plotly_chart(recently_point_pig)
                st.info('날짜별 팀의 득점 정보 입니다.')
            if '어시스트' in away_multi :
                #어시스트 데이터
                st.subheader('어시스트')
                recently_game = st.slider('어웨이 경기 어시스트 경기 수',min_value=3,max_value=int(df_games_away['경기ID'].count()),value=7)
                recently_assist_pig = px.bar(df_games_away.head(recently_game),x='경기날짜',y=['홈팀어시','어웨이팀어시'],barmode='group')
                st.plotly_chart(recently_assist_pig)
                st.info('날짜별 팀의 어시스트 정보 입니다.')
            if '리바운드' in away_multi :    
                #리바운드 데이터
                st.subheader('리바운드')
                recently_game = st.slider('어웨이 경기 리바운드 경기 수',min_value=3,max_value=int(df_games_away['경기ID'].count()),value=7)
                recently_rebound_pig = px.bar(df_games_away.head(recently_game),x='경기날짜',y=['홈팀리바운드','어웨이팀리바운드'],barmode='group')
                st.plotly_chart(recently_rebound_pig)
                st.info('날짜별 팀의 리바운드 정보 입니다.')
           
            if '역대전적' in away_multi :
                st.subheader('역대 어웨이 전적비교')
                compare_away_team = st.selectbox('팀 선택',team_name_list)
            
                if compare_away_team != '' and compare_away_team != team_name: 
                    compare_team_id_away = df_teams[df_teams['팀약어'] == compare_away_team]['팀ID'].values[0]
                    data_away=df_games[(df_games['홈팀ID'] == compare_team_id_away) & (df_games['어웨이팀ID'] ==team_id)]
                    st.dataframe(data_away.iloc[:,[11,0,3,4,5,12,7,8,9,10]].sort_values('경기날짜',ascending=False))

                    if data_away.empty == False :
                        
                        data_away = data_away.iloc[:,1:10+1].mean()
                        data_away['어웨이승리'] = 1 - data_away['홈팀승리여부']
                        fig_away = plt.figure()
                        plt.subplot(2,2,1)
                        plt.pie(data_away[[10,9]],autopct='%.1f',startangle = 90)
                        plt.title('어웨이팀 승률')
                        plt.legend(['어웨이','홈'])
                        
                        plt.subplot(2,2,2)
                        plt.pie(data_away[[6,2]],autopct='%.1f',startangle=90)
                        plt.title('평균 득점')
                        plt.legend(['어웨이','홈'])

                        plt.subplot(2,2,3)
                        plt.pie(data_away[[7,3]],autopct='%.1f',startangle=90)
                        plt.title('평균 어시')
                        plt.legend(['어웨이','홈'])

                        plt.subplot(2,2,4)
                        plt.pie(data_away[[8,4]],autopct='%.1f',startangle=90)
                        plt.title('평균 리바운드')
                        plt.legend(['어웨이','홈'])
                        st.pyplot(fig_away)
                    else :
                        st.title('')
                elif compare_away_team == team_name :
                    st.error('같은 팀 입니다. 다른 팀을 선택해주세요.')
                else : 
                    st.error('팀을 선택해주세요')

            if '선수 스탯' in away_multi :
                st.subheader('어웨이경기 선수 스탯')
                home_away_id = df_games_away['경기ID']  
                away_team_player_info = df_games_detail[(df_games_detail['경기ID'].isin(home_away_id)) & (df_games_detail['팀ID'] == team_id)].iloc[:,3:].groupby('선수명').mean()
                st.dataframe(away_team_player_info)
                st.info('선수의 자세한 스탯은 카테고리 - 선수 를 이용해주세요.')
            else :
                st.write('')