1
pip install streamlit

1
streamlit hello

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
@st.cache_data
def get_UN_data():
    AWS_BUCKET_URL = "https://streamlit-demo-data.s3-us-west-2.amazonaws.com"
    df = pd.read_csv(AWS_BUCKET_URL + "/agri.csv.gz")
    return df.set_index("Region")

try:
    df = get_UN_data()
    countries = st.multiselect(
        "Choose countries", list(df.index), ["China", "United States of America"]
    )
    if not countries:
        st.error("Please select at least one country.")
    else:
        data = df.loc[countries]
        data /= 1000000.0
        st.subheader("Gross agricultural production ($B)")
        st.dataframe(data.sort_index())

        data = data.T.reset_index()
        data = pd.melt(data, id_vars=["index"]).rename(
            columns={"index": "year", "value": "Gross Agricultural Product ($B)"}
        )
        chart = (
            alt.Chart(data)
            .mark_area(opacity=0.3)
            .encode(
                x="year:T",
                y=alt.Y("Gross Agricultural Product ($B):Q", stack=None),
                color="Region:N",
            )
        )
        st.altair_chart(chart, use_container_width=True)
except URLError as e:
    st.error(f"This demo requires internet access. Connection error: {e.reason}")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
progress_bar = st.sidebar.progress(0)
status_text = st.sidebar.empty()
last_rows = np.random.randn(1, 1)
chart = st.line_chart(last_rows)

for i in range(1, 101):
    new_rows = last_rows[-1, :] + np.random.randn(5, 1).cumsum(axis=0)
    status_text.text(f"{i}% complete")
    chart.add_rows(new_rows)
    progress_bar.progress(i)
    last_rows = new_rows
    time.sleep(0.05)

progress_bar.empty()

# Streamlit widgets automatically run the script from top to bottom. Since
# this button is not connected to any other logic, it just causes a plain
# rerun.
st.button("Rerun")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
@st.cache_data
def from_data_file(filename):
    url = (
        "https://raw.githubusercontent.com/streamlit/"
        "example-data/master/hello/v1/%s" % filename
    )
    return pd.read_json(url)

try:
    ALL_LAYERS = {
        "Bike rentals": pdk.Layer(
            "HexagonLayer",
            data=from_data_file("bike_rental_stats.json"),
            get_position=["lon", "lat"],
            radius=200,
            elevation_scale=4,
            elevation_range=[0, 1000],
            extruded=True,
        ),
        "Bart stop exits": pdk.Layer(
            "ScatterplotLayer",
            data=from_data_file("bart_stop_stats.json"),
            get_position=["lon", "lat"],
            get_color=[200, 30, 0, 160],
            get_radius="[exits]",
            radius_scale=0.05,
        ),
        "Bart stop names": pdk.Layer(
            "TextLayer",
            data=from_data_file("bart_stop_stats.json"),
            get_position=["lon", "lat"],
            get_text="name",
            get_color=[0, 0, 0, 200],
            get_size=10,
            get_alignment_baseline="'bottom'",
        ),
        "Outbound flow": pdk.Layer(
            "ArcLayer",
            data=from_data_file("bart_path_stats.json"),
            get_source_position=["lon", "lat"],
            get_target_position=["lon2", "lat2"],
            get_source_color=[200, 30, 0, 160],
            get_target_color=[200, 30, 0, 160],
            auto_highlight=True,
            width_scale=0.0001,
            get_width="outbound",
            width_min_pixels=3,
            width_max_pixels=30,
        ),
    }
    st.sidebar.subheader("Map layers")
    selected_layers = [
        layer
        for layer_name, layer in ALL_LAYERS.items()
        if st.sidebar.checkbox(layer_name, True)
    ]
    if selected_layers:
        st.pydeck_chart(
            pdk.Deck(
                map_style=None,
                initial_view_state={
                    "latitude": 37.76,
                    "longitude": -122.4,
                    "zoom": 11,
                    "pitch": 50,
                },
                layers=selected_layers,
            )
        )
    else:
        st.error("Please choose at least one layer above.")
except URLError as e:
    st.error(
        """
        **This demo requires internet access.**
        Connection error: %s
    """
        % e.reason
    )

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
# Interactive Streamlit elements, like these sliders, return their value.
# This gives you an extremely simple interaction model.
iterations = st.sidebar.slider("Level of detail", 2, 20, 10, 1)
separation = st.sidebar.slider("Separation", 0.7, 2.0, 0.7885)

# Non-interactive elements return a placeholder to their location
# in the app. Here we're storing progress_bar to update it later.
progress_bar = st.sidebar.progress(0)

# These two elements will be filled in later, so we create a placeholder
# for them using st.empty()
frame_text = st.sidebar.empty()
image = st.empty()

m, n, s = 960, 640, 400
x = np.linspace(-m / s, m / s, num=m).reshape((1, m))
y = np.linspace(-n / s, n / s, num=n).reshape((n, 1))

for frame_num, a in enumerate(np.linspace(0.0, 4 * np.pi, 100)):
    # Here were setting value for these two elements.
    progress_bar.progress(frame_num)
    frame_text.text("Frame %i/100" % (frame_num + 1))

    # Performing some fractal wizardry.
    c = separation * np.exp(1j * a)
    Z = np.tile(x, (n, 1)) + 1j * np.tile(y, (1, m))
    C = np.full((n, m), c)
    M: Any = np.full((n, m), True, dtype=bool)
    N = np.zeros((n, m))

    for i in range(iterations):
        Z[M] = Z[M] * Z[M] + C[M]
        M[np.abs(Z) > 2] = False
        N[M] = i

    # Update the image placeholder by calling the image() function on it.
    image.image(1.0 - (N / N.max()), use_container_width=True)

# We clear elements by calling empty on them.
progress_bar.empty()
frame_text.empty()

# Streamlit widgets automatically run the script from top to bottom. Since
# this button is not connected to any other logic, it just causes a plain
# rerun.
st.button("Rerun")

1
2
3
4
import streamlit as st

st.title("Hello Streamlit! 🚀")
st.write("이것은 Streamlit으로 만든 간단한 웹 애플리케이션입니다.")

1
streamlit run hello_streamlit.py

1
2
  st.write("안녕하세요, Streamlit입니다!")
  st.write(12345)

1
  st.header("이것은 헤더입니다")

1
  st.subheader("이것은 서브헤더입니다")

1
2
  st.markdown("# 큰 제목 (Markdown)")
  st.markdown("**굵은 글씨**와 *이탤릭체* 사용 가능")

1
  st.caption("이것은 캡션(설명)입니다.")

1
2
3
4
  st.code("""
          def hello():
              print("Hello, Streamlit!")
          """, language="python")

1
  st.latex(r"E = mc^2")

1
2
  name = st.text_input("이름을 입력하세요")
  st.write(f"입력된 이름: {name}")

1
2
  age = st.number_input("나이를 입력하세요", min_value=0, max_value=100, step=1)
  st.write(f"입력된 나이: {age}")

1
2
  selected_date = st.date_input("날짜 선택")
  st.write(f"선택한 날짜: {selected_date}")

1
2
  selected_time = st.time_input("시간 선택")
  st.write(f"선택한 시간: {selected_time}")

1
2
  message = st.text_area("메시지를 입력하세요")
  st.write(f"입력된 메시지:\n{message}")

1
2
3
  uploaded_file = st.file_uploader("파일을 업로드하세요")
  if uploaded_file is not None:
      st.write("업로드된 파일:", uploaded_file.name)

1
2
  color = st.color_picker("색상을 선택하세요", <"#00f900")
  st.write(f"선택한 색상: {color}")

1
2
  if st.button("클릭하세요"):
      st.write("버튼이 클릭되었습니다!")

1
2
3
  agree = st.checkbox("동의합니다")
  if agree:
      st.write("동의하셨습니다!")

1
2
  selected_option = st.radio("옵션을 선택하세요", ("옵션 1", "옵션 2", "옵션 3"))
  st.write(f"선택된 옵션: {selected_option}")

1
2
  fruit = st.selectbox("과일을 선택하세요", ["사과", "바나나", "오렌지"])
  st.write(f"선택한 과일: {fruit}")

1
2
  planets = st.multiselect("행성을 선택하세요", ["목성", "화성", "해왕성"])
  st.write(f"선택한 행성: {planets}")

1
2
  number = st.slider("숫자를 선택하세요", 0, 50)
  st.write(f"선택된 숫자: {number}")

1
2
  rating = st.select_slider("평가를 선택하세요", ["나쁨", "보통", "좋음", "최고"])
  st.write(f"선택한 평가: {rating}")

1
2
3
4
5
  import streamlit as st
  from PIL import Image

  image = Image.open("example.jpg")  -  로컬 이미지 파일
  st.image(image, caption="예제 이미지", use_column_width=True)

1
  st.audio("example.mp3")

1
  st.video("example.mp4")

1
  st.write(df)

1
  st.dataframe(df)

1
  st.table(df)

1
2
3
4
5
  st.json({
      '이름': '이시현',
      '나이': 24,
      '거주지': '광주'
  })

1
2
st.metric(label="LG전자", value="78,000원", delta="2.12%")
st.metric(label="현대차", value="150,000원", delta="-1.25%")

1
2
3
4
5
6
7
8
  import streamlit as st
  import matplotlib.pyplot as plt
  import numpy as np

  rand = np.random.normal(1, 2, size=20)  # 정규분포 난수 생성
  fig, ax = plt.subplots()
  ax.hist(rand, bins=15)  # 히스토그램 그리기
  st.pyplot(fig)

1
2
3
4
5
6
  import streamlit as st
  import pandas as pd
  import numpy as np

  df = pd.DataFrame(np.random.randn(10, 2), columns=['x', 'y'])
  st.line_chart(df)

1
2
3
4
5
6
  import streamlit as st
  import pandas as pd
  import numpy as np

  df = pd.DataFrame(np.random.randn(10, 2), columns=['x', 'y'])
  st.bar_chart(df)

1
2
3
4
5
6
  import streamlit as st
  import pandas as pd
  import numpy as np

  df = pd.DataFrame(np.random.randn(10, 2), columns=['x', 'y'])
  st.area_chart(df)

1
2
3
4
5
6
7
8
9
10
  import streamlit as st
  import pandas as pd
  import numpy as np
  import altair as alt

  df = pd.DataFrame(np.random.randn(500, 3), columns=['x', 'y', 'z'])
  chart = alt.Chart(df).mark_circle().encode(
      x='x', y='y', size='z', color='z', tooltip=['x', 'y', 'z']
  )
  st.altair_chart(chart, use_container_width=True)

1
2
3
4
5
6
7
8
9
10
11
  import streamlit as st
  import graphviz

  st.graphviz_chart('''
      digraph {
          Big_shark -> Tuna
          Tuna -> Mackerel
          Mackerel -> Small_fishes
          Small_fishes -> Shrimp
      }
  ''')

1
2
3
4
5
6
7
8
9
  import pandas as pd
  import numpy as np
  import streamlit as st

  df = pd.DataFrame(
      np.random.randn(500, 2) / [50, 50] + [37.76, -122.4],  # 샌프란시스코 주변 랜덤 좌표 생성
      columns=['lat', 'lon']
  )
  st.map(df)

1
2
3
4
5
6
7
8
  import streamlit as st
  import time  

  progress_bar = st.progress(0)  # 초기값 0

  for percent in range(0, 101, 10):
      time.sleep(0.1)  # 프로세스 진행 시뮬레이션
      progress_bar.progress(percent)  # 진행률 업데이트

1
2
3
4
5
6
  import streamlit as st
  import time  

  with st.spinner("잠시만 기다려 주세요..."):
      time.sleep(5)  # 대기 시간 시뮬레이션
  st.success("작업 완료!")

1
2
3
4
  import streamlit as st

  st.success("작업이 성공적으로 완료되었습니다!")
  st.balloons()  # 축하 애니메이션

1
  st.success("축하합니다! 모든 작업이 성공적으로 완료되었습니다.")

1
  st.error("오류가 발생했습니다. 다시 시도해주세요.")

1
  st.warning("이 작업은 주의가 필요합니다.")

1
  st.info("Streamlit을 사용하면 쉽게 웹 앱을 만들 수 있습니다.")

1
  st.exception(RuntimeError("RuntimeError 예외 발생"))

1
2
3
4
5
6
7
8
  import streamlit as st

  st.sidebar.title("사이드바 메뉴")
  st.sidebar.markdown("여기에 설정을 추가할 수 있습니다.")

  # 사이드바 요소 추가
  option = st.sidebar.radio("옵션 선택", ["옵션 A", "옵션 B", "옵션 C"])
  st.sidebar.button("사이드바 버튼")

1
2
3
4
  col1, col2 = st.columns(2)

  col1.write("첫 번째 컬럼")
  col2.write("두 번째 컬럼")

1
2
3
4
5
6
7
8
9
10
11
12
13
  col1, col2, col3 = st.columns([2, 6, 2])

  with col1:
      st.header('Col1')
      st.image('https://static.streamlit.io/examples/cat.jpg')

  with col2:
      st.header('Col2')
      st.image('https://static.streamlit.io/examples/dog.jpg')

  with col3:
      st.header('Col3')
      st.image('https://static.streamlit.io/examples/owl.jpg')

1
2
  with st.container():
      st.write("이것은 컨테이너 내부입니다.")

1
2
3
4
5
6
7
8
9
10
11
12
13
  tab1, tab2, tab3 = st.tabs(['Cat', 'Dog', 'Owl'])

  with tab1:
      st.header('고양이')
      st.image('https://static.streamlit.io/examples/cat.jpg')

  with tab2:
      st.header('강아지')
      st.image('https://static.streamlit.io/examples/dog.jpg')

  with tab3:
      st.header('올빼미')
      st.image('https://static.streamlit.io/examples/owl.jpg')

1
2
  with st.expander("더 보기"):
      st.write("이곳에 추가 정보를 입력할 수 있습니다.")

1
2
3
  with st.expander("고양이 정보 보기"):
      st.write("여기에는 고양이에 대한 정보가 들어갑니다.")
      st.image('https://static.streamlit.io/examples/cat.jpg', width=200)

1
streamlit run app.py --server.port 8080

1
streamlit run app.py --server.address 0.0.0.0 --server.port 8080

1
2
3
4
5
6
7
8
FROM python:3.9

WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .

CMD ["streamlit", "run", "app.py", "--server.address=0.0.0.0", "--server.port=8501"]

1
2
docker build -t my-streamlit-app .
docker run -p 8501:8501 my-streamlit-app