streamlit UI控件使用大全_streamlit 示例

streamlit UI控件使用大全

速查表

experimental_user_info_proxy 获取当前用户的个人信息

Streamlit中的experimental_user_info_proxy是一个实验性的功能，用于获取当前用户的个人信息。它是一个代理对象，可以通过调用其方法来获取用户信息。

要使用experimental_user_info_proxy，首先需要启用实验性功能。可以通过在Streamlit的配置文件中设置experimental_features列表来实现。将user_info_proxy添加到该列表中以启用该功能。

启用实验性功能后，可以在Streamlit应用程序中使用experimental_user_info_proxy来获取用户信息。可以使用get_current_user_info方法获取当前用户的个人信息，该方法返回一个包含用户信息的字典对象。

以下是一个简单的示例代码，演示如何使用experimental_user_info_proxy获取用户信息：

import streamlit as st

# 启用实验性功能
st.experimental_feature_warning('user_info_proxy')

# 获取当前用户信息
user_info = st.experimental_user_info_proxy.get_current_user_info()

# 显示用户信息
st.write('Username:', user_info['username'])
st.write('Email:', user_info['email'])
st.write('First Name:', user_info['first_name'])
st.write('Last Name:', user_info['last_name'])
1
2
3
4
5
6
7
8
9
10
11
12
13

在这个示例中，我们首先启用实验性功能，然后使用experimental_user_info_proxy.get_current_user_info方法获取当前用户的个人信息。最后，我们使用st.write方法显示用户的信息。

需要注意的是，由于该功能是实验性的，可能存在不稳定或不支持的情况。建议在使用前先查看Streamlit的官方文档或社区讨论，以了解该功能的最新状态和使用注意事项。

secrets和session_state 存储

在 Streamlit 中，st.secrets 和 st.session_state 都是用于存储和保护敏感数据的工具，但它们的使用场景和功能有所不同。

st.secrets 用于存储敏感数据，如 API 密钥、密码等。这些数据在 Streamlit 应用中是可用的，但只有经过授权的用户才能访问。你可以使用 st.secrets 来安全地存储和管理这些数据，确保只有合适的用户能够访问。

st.session_state 用于在 Streamlit 会话期间跟踪和管理状态。它可以帮助你在不同的请求之间持久化和共享状态，以及在用户会话期间自动轮换状态。st.session_state 可以用于存储任何对象，并且可以在应用初始化时进行整体重置，但在重新运行（rerun）时不会重置。你可以使用回调函数来修改和调用它的值，以实现互动组件的嵌套等功能。

总的来说，st.secrets 用于存储和管理敏感数据，而 st.session_state 用于在会话期间跟踪和管理状态。根据你的需求和使用场景选择合适的工具。

总的来说，st.secrets 用于存储和管理敏感数据，而 st.session_state 用于在会话期间跟踪和管理状态。根据你的需求和使用场景选择合适的工具。

以下是使用 Streamlit 中的 st.secrets 和 st.session_state 的示例：

使用 st.secrets 存储敏感数据：

import streamlit as st

# 存储敏感数据
st.secrets.config({
    'api_key': 'your-api-key',
    'password': 'your-password'
})

# 获取敏感数据
api_key = st.secrets.get('api_key')
password = st.secrets.get('password')

# 在应用中使用敏感数据
st.write(f"使用 API Key: {api_key}")
st.write(f"使用 Password: {password}")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

使用 st.session_state 跟踪和管理状态：

import streamlit as st

# 初始化会话状态
st.session_state.config({
    'selected_option': 'option1'
})

# 更新会话状态
@st.cache
def update_session_state():
    st.session_state['selected_option'] = 'option2'
    return st.session_state['selected_option']

# 在应用中使用会话状态
if st.session_state['selected_option'] == 'option1':
    st.write("选择选项1")
else:
    st.write("选择选项2")
    
# 更新会话状态并使用回调函数实现联动效果
update_session_state()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

sidebar 侧边栏

在Streamlit中，可以使用st.sidebar.element_name语法将大部分可放入应用程序中的元素放入侧边栏中。以下是一些示例：

• st.sidebar.markdown()
• st.sidebar.slider()
• st.sidebar.line_chart()
• st.beta_columns并排布置小部件
• st.beta_expander通过隐藏大量内容来节省空间

可以自由选择使用。

altair_chart 显示Altair图表的方法

altair_chart是Streamlit的一个方法，它使用Altair库来显示指定的图表。Altair是一个Python数据可视化库，它以Vega和Vega-Lite可视化语法为基础，支持创建复杂的交互式图表。

altair_chart方法接收一个Altair图表对象作为参数，并且可以设置图表的宽度。例如，streamlit.altair_chart(chart, width=600)会在Streamlit应用中显示宽度为600像素的Altair图表。

要使用Altair图表，首先需要安装Altair库。可以通过运行pip install altair来安装。然后，可以使用Altair的基本对象和方法来创建图表。例如，import altair as alt和chart = alt.Chart(data)可以创建一个新的Altair图表对象。

在Altair图表中，可以使用数据、图表类型和编码等基本方法来定义图表。数据方法接收一个Pandas DataFrame作为参数，可以直接导入数据。例如，data = pd.read_csv('data.csv')可以读取CSV文件中的数据。然后，可以使用chart = alt.Chart(data)来创建一个基于数据的Altair图表对象。

在定义图表时，可以使用mark方法来指定图表类型。例如，chart.mark_bar()可以将图表定义为条形图。还可以使用encode方法来定义图表的颜色、大小等属性。例如，chart.encode('x', 'variable:Q', 'color', 'data')可以将变量编码为x轴、颜色和数据。

通过使用这些方法，可以创建各种类型的图表，包括柱状图、折线图、散点图等。在创建完图表后，可以使用streamlit.altair_chart()方法将其显示在Streamlit应用中。

area_chart 创建和显示区域图

Streamlit area_chart是一种在Streamlit应用中显示区域图的方法。区域图是一种常见的图表类型，用于展示不同类别的数据随时间或其他变量的变化趋势，并强调每个类别在总体中所占的比例。这种图表通常由多个区域堆叠而成，每个区域代表一个数据类别，沿着横轴表示时间或其他变量的维度。每个类别的数据值在纵轴上表示。

使用Streamlit area_chart方法，可以在Streamlit应用中方便地创建和显示区域图。要使用该方法，需要先准备要绘制的数据，并将其传递给area_chart方法。同时，还可以设置图表的宽度和高度参数。

在具体实现中，可以通过以下步骤进行：

1. 准备数据：将要绘制的数据准备好，可以使用pandas、numpy、dict等类型的数据结构来存储和处理数据。
2. 调用area_chart方法：在Streamlit应用中调用area_chart方法，并将准备好的数据作为参数传递给它。例如，可以使用st.area_chart(data)来创建一个区域图。
3. 设置图表参数：如果需要，可以通过设置width和height参数来调整图表的宽度和高度。例如，可以使用st.area_chart(data, width=800, height=600)来创建一个宽度为800像素、高度为600像素的区域图。

需要注意的是，Streamlit area_chart方法的使用方式与其他的Streamlit图表方法类似，只需要将数据和处理逻辑准备好，然后在Streamlit应用中调用相应的方法即可。同时，在使用该方法时，还需要注意数据的处理和格式转换等细节问题。

Audio 播放音频的方法

Streamlit Audio是一种在Streamlit应用中播放音频的方法。它允许用户通过使用Streamlit的audio方法来显示一个音频播放器，并播放原始音频数据。

在Streamlit Audio中，可以播放的音频数据类型包括URL字符串（指向本地或远程文件）、字节码流、BytesIO对象和numpy.ndarray。播放的起始时间可以通过start_time参数进行设置。同时，音频文件的MIME类型也可以通过format参数进行设置，默认为audio/wav。

以上信息仅供参考，如需了解更多信息，建议查阅Streamlit官方文档或咨询专业技术人员。

balloons 展示庆祝气球

在Streamlit中，balloons是一种展示庆祝气球的方法。通过使用streamlit.balloons()函数，你可以在Streamlit应用中展示一个庆祝气球。这个函数没有参数，只需要调用它即可在应用中显示一个庆祝气球。

在具体实现中，你可以将streamlit.balloons()函数放在你想要展示庆祝气球的代码行之后，这样在执行到该代码行时，应用中就会显示一个庆祝气球。

需要注意的是，Streamlit中的balloons方法只是展示一个静态的庆祝气球图像，而不会进行任何交互或动画效果。如果你需要更复杂的交互或动画效果，可能需要使用其他方法或库来实现。

bar_chart 创建和显示柱状图

Streamlit中的bar_chart方法可用于在Streamlit应用程序中创建和显示柱状图。柱状图是一种常用的数据可视化图表，可以用于比较不同类别或数据组之间的差异。

要使用Streamlit的bar_chart方法，需要准备要绘制的数据，并将其传递给bar_chart方法。数据可以是pandas DataFrame、numpy数组、可迭代对象或字典等类型。同时，还可以设置图表的宽度和高度参数。

在具体实现中，可以使用以下代码示例来创建一个简单的柱状图：

import streamlit as st

# 准备数据
chart_data = pd.DataFrame({
    'A': [20, 30, 50],
    'B': [10, 25, 60],
    'C': [30, 45, 70]
})

# 创建柱状图
st.bar_chart(chart_data)
1
2
3
4
5
6
7
8
9
10
11

在这个示例中，我们首先准备了一个包含数据的pandas DataFrame，其中每一列代表一个类别，每一行代表一个数据点。然后，我们使用st.bar_chart方法将数据传递给它，以创建柱状图。

需要注意的是，Streamlit的bar_chart方法默认情况下会按照数据的顺序进行分类和排序。如果需要自定义分类和排序方式，可以在创建柱状图之前对数据进行处理和转换。同时，在使用Streamlit的图表方法时，还需要注意数据的处理和格式转换等细节问题。

bokeh_chart 创建和显示图表

Streamlit中的bokeh_chart方法允许你在Streamlit应用中使用Bokeh库创建和显示图表。Bokeh是一种用于交互式数据可视化的Python库，它支持创建复杂的散点图、折线图、条形图等类型的图表。

要使用Streamlit的bokeh_chart方法，需要准备要绘制的Bokeh图表，并使用st.bokeh_chart方法将其显示在Streamlit应用中。在本回答中，我们假设你已经创建了一个名为figure的Bokeh图表对象。

在具体实现中，可以使用以下代码示例将Bokeh图表显示在Streamlit应用中：

import streamlit as st
from bokeh.plotting import figure

# 准备数据
x = [1, 2, 3, 4, 5]
y = [6, 7, 2, 4, 5]

# 创建Bokeh图表
p = figure(title='simple line example', x_axis_label='x', y_axis_label='y')
p.line(x, y, legend_label='Trend', line_width=2)

# 在Streamlit应用中显示Bokeh图表
st.bokeh_chart(p)
1
2
3
4
5
6
7
8
9
10
11
12
13

在这个示例中，我们首先准备了一个简单的数据集，然后使用figure方法创建了一个Bokeh图表对象。在该图表中，我们使用line方法绘制了一条折线图，并设置了图表的标题、x轴标签、y轴标签和图例。最后，我们使用st.bokeh_chart方法将图表显示在Streamlit应用中。

需要注意的是，在使用Streamlit的bokeh_chart方法时，需要确保已经安装了Bokeh库和相关的依赖项。同时，还需要根据具体需求对数据进行处理和格式转换等操作。

button 创建一个按钮

Streamlit中的button方法可以用来创建一个按钮，用户可以通过点击按钮来触发某些操作或事件。

button方法接受一个字符串参数label，表示按钮的标题或标签。同时，还可以设置一个可选的键值key，用来唯一标识这个按钮组件。

使用button方法后，返回一个布尔值，表示在上个应用周期中按钮是否被点击。

以下是一个简单的示例：

import streamlit as st

if st.button('Click me'):
    # 在这里执行按钮点击后的操作
    st.write('Button clicked!')
1
2
3
4
5

在这个示例中，当用户点击"Click me"按钮时，程序将执行if语句块中的代码，并输出"Button clicked!"。

cache 缓存重复的数据读取和复杂程序执行的过程

Streamlit中的cache方法可以用来缓存重复的数据读取和复杂程序执行的过程，以减少重复执行的次数和用户等待时间。

在具体实现中，可以通过在函数定义时添加@st.cache装饰器来标记需要缓存的函数。当第一次调用带有@st.cache装饰器的函数时，Streamlit会运行函数并将结果保存在本地缓存中。下次再调用该函数时，如果没有变化，Streamlit就会直接利用缓存中的结果，避免了重复的计算和数据读取。

使用Streamlit的cache方法可以提高应用的性能和用户体验，但需要注意以下几点：

1. 缓存的数据只在当前应用周期内有效，重启应用后缓存会被清除。
2. 默认情况下，Streamlit会在本地工作目录中创建缓存文件，如果应用需要频繁读取或计算大量数据，可能会占用较多的磁盘空间。
3. 如果函数不是确定性的（例如输出依赖于随机数）或者从外部拉取时变数据（例如股票行情），则Streamlit无法判断是否发生了变化，也就无法正确地使用缓存。
4. Streamlit官方在0.89版本增加了新的效率更高的缓存方式，并将数据与单例缓存分成两个装饰器方法。同时，也增加了一个名为st.experimental_memo的实验性方法，该方法可以用来缓存任意可序列化的对象。

综上所述，使用Streamlit的cache方法可以提高应用的性能和用户体验，但在使用时需要注意适用场景和限制条件。

cache_data 缓存数据

在Streamlit中，cache_data用于缓存数据，尤其是可序列化的数据类型，如数据帧、NumPy数组、字符串、整数、浮点数等。当第一次运行被@st.cache_data修饰的函数时，Streamlit会运行代码并将返回值储存在缓存中。之后每次运行同样的函数和输入时，Streamlit会跳过执行直接返回缓存中的值作为替换。

cache_data建议缓存计算数据，例如载入从CSV导入的数据、转换的np数组、api、或者其它序列数据。它会创建源数据的拷贝。

总的来说，cache_data方法可以显著提高性能，特别是对于复杂计算或需要大量数据处理的情况。

cache_resource 缓存全局资源

Streamlit中的cache_resource方法可以用于缓存全局资源，例如机器学习模型或数据库连接。这些资源在应用的所有重新运行和会话之间共享。相比cache_data，cache_resource主要用于缓存不可序列化的对象，如机器学习模型等。

camera_input 直接从网络摄像头捕获照片

Streamlit中的camera_input方法允许用户直接从网络摄像头捕获照片。这个组件可以用于创建实时视频流或捕捉照片的功能。

camera_input方法的使用方式如下：

import streamlit as st

# 使用camera_input方法
image = st.camera_input("Take a photo")
1
2
3
4

在这个例子中，“Take a photo”是用户界面上显示的一个标签，用于描述这个组件的功能。当用户按下“Take a photo”按钮时，会从摄像头捕获一张照片，并将这张照片以base64编码的形式返回。

注意，上述代码片段只是简单的示例，实际使用时可能需要根据具体需求进行更多的处理和操作。

caption 添加解释性文字

在Streamlit中，caption函数用于添加解释性文字，通常用于解释上面的内容或提供额外的上下文。它接受一个字符串作为参数，该字符串可以包含要显示为图例的文本。

例如，以下代码片段演示了如何使用caption函数：

import streamlit as st

st.image('image.png', caption='This is an image of a sunset.')
1
2
3

在这个例子中，st.image函数用于显示一张名为"image.png"的图片，并使用caption函数添加了一个解释性文字，即"This is an image of a sunset."。这个解释性文字将显示在图片的下方，以帮助用户更好地理解图片的内容。

checkbox 创建一个复选框

在Streamlit中，checkbox方法用于创建一个复选框，用户可以通过勾选或取消勾选复选框来选择或取消选择某些选项。

checkbox方法接受一个标签参数label，用于描述复选框的功能。当用户点击复选框时，Streamlit会根据用户的选择返回一个布尔值。

以下是一个简单的示例：

import streamlit as st

if st.checkbox('Do you like Streamlit?'):
    st.write('Great! Streamlit is awesome!')
else:
    st.write('Streamlit could use some improvements.')
1
2
3
4
5
6

在这个例子中，复选框的标签为"Do you like Streamlit?“。当用户勾选复选框时，Streamlit会返回True，并显示"Great! Streamlit is awesome!”；当用户取消勾选复选框时，Streamlit会返回False，并显示"Streamlit could use some improvements."。

注意，复选框的功能可能会根据具体的应用场景和需求而有所不同。在使用checkbox方法时，需要根据具体需求进行更多的处理和操作。

code 显示代码

Streamlit中的code方法可以用于显示代码。它接受两个参数：body和language。body参数是要显示的代码，而language参数是代码所使用的开发语言。

此外，如果省略language参数，Streamlit将不会为代码提供语法高亮效果。

以下是一个使用Streamlit的code方法的示例：

import streamlit as st

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

这段代码将显示一个Python语言的代码块，其中定义了一个名为"hello"的函数，该函数打印出"Hello, Streamlit!"。

除了显示代码块，Streamlit还提供了其他多种显示方法，如st.write方法、st.title方法、st.header方法、st.markdown方法等。这些方法可以根据需要添加到Streamlit应用中，以实现不同的显示效果。

color_picker 显示颜色选择器小部件

Streamlit中的color_picker方法可以用于显示颜色选择器小部件，允许用户从颜色选择器中选择颜色。

color_picker方法接受一个或多个参数，包括label、value、key、help、on_change、args和kwargs。其中，label参数是颜色选择器小部件的标签，value参数是默认选择的颜色，key参数是用于唯一标识这个颜色选择器小部件的字符串，help参数是对颜色选择器小部件的描述信息，on_change参数是一个回调函数，当用户选择新的颜色时将触发该函数。

以下是一个使用Streamlit的color_picker方法的示例：

import streamlit as st

color = st.color_picker('Pick a color', value='#000000')
st.write('You picked', color)
1
2
3
4

在这个例子中，用户可以通过点击"Pick a color"按钮从颜色选择器中选择颜色。当用户选择新的颜色后，页面将更新并显示"You picked [新选择的颜色]"。

columns 创建多列布局

Streamlit中的columns方法可以用于创建多列布局。通过columns方法，可以将应用程序的界面分成多个列，每一列可以包含不同的组件。这样可以更好地组织应用程序，并使其更加易于使用。

columns方法接受一个参数spec，它是一个表示列布局的列表或元组。每个元素代表一列，可以是字符串、数字或布尔值。如果spec参数为空，则默认包含一个空列。

下面是一个使用columns方法的示例：

import streamlit as st

with st.columns(2): # 创建一个两列布局
    with st.column(0): # 第一列
        st.header("Column 1")
        st.image("https://example.com/image1.jpg")
    with st.column(1): # 第二列
        st.header("Column 2")
        st.image("https://example.com/image2.jpg")
1
2
3
4
5
6
7
8
9

这个示例创建了一个两列布局，第一列包含一个标题和一个图片，第二列包含一个标题和另一个图片。通过使用columns方法和column方法，可以方便地实现多列布局，并更好地组织应用程序的界面。

container 创建一个容器

Streamlit中的container方法可以用于创建一个容器，该容器可用于容纳多个元素。

使用container方法可以创建一个不可见的容器，该容器可用于在应用程序中插入多个元素。这些元素可以是按钮、复选框、文本框等等。通过使用container方法，可以更好地组织应用程序的界面，并允许用户以更灵活的方式使用这些元素。

下面是一个使用container方法的示例：

import streamlit as st

with st.container():
    st.write("Hello")
    st.button("Click me!")
    st.checkbox("Check me!")
1
2
3
4
5
6

这个示例创建了一个容器，并在其中添加了一个文本框、一个按钮和一个复选框。通过使用container方法，可以将这些元素组织在一起，并以更有条理的方式呈现给用户。

data_editor 允许用户以交互方式编辑数据框

Streamlit中的data_editor函数允许用户以交互方式编辑数据框（data frame）。它提供了一个方便的界面，使用户能够查看和编辑数据框中的数据。

data_editor函数接受一个数据框对象作为参数，并在Streamlit应用程序中创建一个界面，使用户可以编辑该数据框。用户可以添加、删除或修改数据框中的行和列，以及查看每列的统计信息。

下面是一个使用data_editor函数的示例：

import streamlit as st
import pandas as pd

# 创建一个示例数据框
df = pd.DataFrame({
    'Name': ['Alice', 'Bob', 'Charlie'],
    'Age': [25, 30, 35],
    'Gender': ['F', 'M', 'M']
})

# 显示数据框编辑器
st.data_editor(df)
1
2
3
4
5
6
7
8
9
10
11
12

在这个示例中，我们首先创建了一个包含姓名、年龄和性别信息的示例数据框。然后，我们使用data_editor函数将该数据框显示在Streamlit应用程序中，并允许用户编辑它。用户可以通过界面添加、删除或修改数据框中的行和列，以及查看每列的统计信息。

需要注意的是，data_editor函数只适用于较小的数据框，因为它会将整个数据框加载到内存中。对于较大的数据框，可能需要使用其他方法来编辑数据。

dataframe 创建和操作数据框

Streamlit中的dataframe模块可以用于创建和操作数据框（data frame）。数据框是一种常见的数据结构，通常用于存储和组织表格数据。在Streamlit中，可以使用dataframe模块来创建、查询、过滤、变换和可视化数据框。

下面是一些使用Streamlit中dataframe模块的示例：

1. 创建数据框：

import pandas as pd

# 创建一个示例数据框
df = pd.DataFrame({
    'Name': ['Alice', 'Bob', 'Charlie'],
    'Age': [25, 30, 35],
    'Gender': ['F', 'M', 'M']
})

# 在Streamlit中显示数据框
st.dataframe(df)
1
2
3
4
5
6
7
8
9
10
11

2. 查询数据框中的数据：

# 查询数据框中特定列的数据
st.write(df['Name'])

# 查询数据框中特定行的数据
st.write(df.loc[0])
1
2
3
4
5

3. 过滤数据框中的数据：

# 过滤出性别为'M'的数据行
male_rows = df[df['Gender'] == 'M']
st.dataframe(male_rows)
1
2
3

4. 变换数据框中的数据：

# 将年龄列中的值增加10岁
df['Age'] = df['Age'] + 10
st.dataframe(df)
1
2
3

5. 可视化数据框中的数据：

# 使用柱状图显示性别分布情况
st.bar_chart(df['Gender'].value_counts())
1
2

date_input 显示一个日期输入框

Streamlit中的date_input方法可以显示一个日期输入框组件。

方法原型为：streamlit.date_input(label, value=None, key=None)

参数说明：

• label：组件说明文本，即输入框旁边的文本。
• value：组件当前值，可以是datetime.date或datetime.datetime类型。默认值为None，表示当前日期。
• key：组件ID，用于在Streamlit应用程序中唯一标识该组件。默认值为None。

返回值：date_input方法返回组件的当前值，即用户输入的日期。

示例代码：

import streamlit as st

# 显示日期输入框，默认值为今天的日期
today = st.date_input('Enter a date', value=None)

# 显示日期输入框，指定一个默认值
default_date = datetime.date(2023, 7, 1)
st.date_input('Enter a date', value=default_date)
1
2
3
4
5
6
7
8

divider 用于添加分隔线

在Streamlit中，st.divider函数用于添加分隔线，以帮助在应用程序中创建视觉分隔。这个函数的使用非常简单，只需要调用它即可添加一条分隔线。例如：

import streamlit as st

st.write('This is some content')
st.divider()
st.write('This is some other content')
1
2
3
4
5

在这个例子中，st.divider函数在两段内容之间添加了一条分隔线，使它们在视觉上有所区分。你可以根据需要调整分隔线的样式和高度。

download_button 创建一个下载按钮

Streamlit中的st.download_button函数可以创建一个下载按钮，用户点击该按钮后可以下载指定的文件内容。这个函数的使用方法如下：

st.download_button(label, data, file_name=None, mime=None, key=None, help=None, on_click=None, args=None, kwargs=None, *, disabled=False)
1

其中，参数说明如下：

• label：按钮的标签文本。
• data：要下载的文件内容，可以是一个字符串、二进制数据或者图像。
• file_name：可选参数，指定下载时显示的文件名。
• mime：可选参数，指定文件的MIME类型。如果指定了该参数，那么在下载按钮上会显示一个对应的文件类型图标。
• key：可选参数，用于唯一标识该按钮。
• help：可选参数，指定当用户将鼠标悬停在按钮上时显示的帮助文本。
• on_click：可选参数，一个回调函数，当用户点击按钮时触发该函数。
• args和kwargs：可选参数，用于传递给回调函数的参数。
• disabled：可选参数，如果设置为True，则按钮将被禁用。

使用示例：

1. 下载字符串内容为文本文件：

text_contents = 'This is some text'
st.download_button('Download some text', text_contents)
1
2

2. 下载二进制数据为文件：

binary_contents = b'example content'
st.download_button('Download binary file', binary_contents)
1
2

3. 下载图像：

import base64
with open('image.png', 'rb') as f:
    image_data = f.read()
    image_b64 = base64.b64encode(image_data).decode()
st.download_button('Download image', image_b64)
1
2
3
4
5

echo 显示应用源代码

在Streamlit中，st.echo方法可以用于显示应用源代码，并且支持在执行代码块的结果之前或之后显示回显代码。它也可以用于显示其他文本信息。使用st.echo方法需要在with块中，这样可以在应用程序上绘制一些代码，然后执行。

示例代码如下：

import streamlit as st

with st.echo():
    st.write('This code will be printed')
1
2
3
4

在这个示例中，st.echo()方法创建了一个with块，在这个块中，st.write('This code will be printed')将会被执行，并且这段代码的输出将会被显示在Streamlit应用程序中。

empty 添加一个占位符

Streamlit中的empty方法可以添加一个占位符，这个占位符可以用于保存单个元素。你可以在返回的容器上插入/替换/清除元素，方法是使用"with" 表示法或直接在返回的对象上调用方法。例如，可以使用如下代码替换占位符的文本：

my_placeholder = st.empty()
my_placeholder.text("Hello world!")
1
2

以上信息仅供参考，如果还有疑问，建议访问Streamlit官网查询相关教程。

error 用于显示错误信息

Streamlit中的error方法可以用于显示错误信息。当Streamlit应用程序中发生错误时，可以使用该方法将错误信息显示在应用程序中，以便用户能够及时发现并解决问题。

示例代码如下：

import streamlit as st

try:
    # 在这里写可能会引发错误的代码
    pass
except Exception as e:
    st.error(str(e))
1
2
3
4
5
6
7

在这个示例中，我们使用了try-except块来捕获可能发生的错误，并将错误信息转换为字符串，然后使用st.error方法将其显示在Streamlit应用程序中。如果程序执行过程中发生了错误，那么这个错误信息将会被显示在应用程序的界面上，方便用户及时发现并解决问题。

exception 用于处理异常

Streamlit中的exception方法可以用于处理异常，以便在发生异常时进行特殊处理，而不是简单地抛出错误。使用该方法可以捕获异常，并在应用程序中进行自定义处理，例如显示错误信息或采取其他适当的措施。

示例代码如下：

import streamlit as st

try:
    # 在这里写可能会引发异常的代码
    pass
except Exception as e:
    st.exception(e)
1
2
3
4
5
6
7

在这个示例中，我们使用了try-except块来捕获可能发生的异常，并使用st.exception方法将异常对象作为参数传递。该方法将会在Streamlit应用程序中显示异常的详细信息，包括异常类型、错误信息和堆栈跟踪等。这样可以帮助用户更好地了解异常的原因和位置，以便更好地解决问题。

expander 一种可展开/折叠的容器

Streamlit中的expander是一种可展开/折叠的容器，可以在应用程序中插入，用来承载多个元素。用户可以点击展开或折叠容器，以便在需要时查看更多内容，同时保持界面的整洁性。

experimental_connection 创建到数据存储或API的新的连接

Streamlit的experimental_connection函数是用于创建到数据存储或API的新的连接，或者返回一个已经存在的连接。该函数可以接受不同的参数来指定连接的细节，例如连接的名称、类型、最大条目数、生存时间（TTL）等。

在具体使用时，experimental_connection函数可以这样调用：

st.experimental_connection(name, type=None, max_entries=None, ttl=None, **kwargs)
1

其中，name参数是连接的名称，type参数是连接类型，可以是"sql"或"snowpark"等，max_entries参数是最大条目数，ttl参数是生存时间。

请注意，experimental_connection函数是实验性的，可能会有变动。在使用时，建议查看Streamlit的官方文档或相关教程以获取最新和详细的信息。

experimental_data_editor 在线的数据编辑器

Streamlit的experimental_data_editor是一个在线的数据编辑器，可以用于创建和编辑数据框（dataframes）。这个功能非常强大，可以调整列宽度、调整表格大小、列排序、快捷搜索，还支持编辑单元格、复制粘贴、添加和删除行等操作。

要使用experimental_data_editor，首先需要导入streamlit库，然后调用experimental_data_editor函数。这个函数接受一个参数，即要编辑的数据框。

以下是一个简单的示例代码：

import streamlit as st
import pandas as pd

# 创建一个示例数据框
df = pd.DataFrame({
    'Name': ['Alice', 'Bob', 'Charlie'],
    'Age': [25, 30, 35],
    'Gender': ['F', 'M', 'M']
})

# 在Streamlit中显示数据框
st.experimental_data_editor(df)
1
2
3
4
5
6
7
8
9
10
11
12

在这个示例中，我们首先创建了一个包含姓名、年龄和性别信息的数据框。然后，我们调用st.experimental_data_editor函数并将数据框作为参数传递给它。这个函数会在Streamlit应用程序中创建一个在线的数据编辑器，用户可以在其中查看和编辑数据框的内容。

experimental_get_query_params 获取当前URL查询参数

Streamlit中的experimental_get_query_params函数用于获取当前URL查询参数。这个函数返回一个字典，其中包含了当前URL中的所有查询参数及其对应的值。

示例代码：

import streamlit as st

# 获取当前URL查询参数
params = st.experimental_get_query_params()

# 显示查询参数
st.write(params)
1
2
3
4
5
6
7

在这个示例中，我们首先导入了streamlit库，然后调用experimental_get_query_params函数来获取当前URL的查询参数。这个函数返回一个字典，其中包含了所有查询参数及其对应的值。最后，我们使用st.write函数将查询参数显示在Streamlit应用程序中。

experimental_memo 实验性的缓存装饰器

Streamlit中的experimental_memo函数是一个实验性的缓存装饰器，它提供了对函数调用结果的缓存功能。通过使用@st.experimental_memo装饰器，可以将一个函数的结果缓存起来，以便在后续的函数调用中直接使用缓存的结果，而不需要重新计算。

experimental_memo函数接受一些参数，用于指定缓存的细节。其中，persist参数用于指定缓存的持久化方式，show_spinner参数用于指定是否在缓存过程中显示加载指示器，suppress_st_warning参数用于指定是否抑制Streamlit的警告信息，max_entries参数用于指定缓存的最大条目数，ttl参数用于指定缓存的生存时间。

示例代码：

import streamlit as st

@st.experimental_memo(persist="disk", show_spinner=False)
def expensive_computation(data):
    # 这里进行一些耗时的计算
    result = compute_something(data)
    return result
1
2
3
4
5
6
7

在这个示例中，我们使用了@st.experimental_memo装饰器来缓存expensive_computation函数的结果。通过指定persist="disk"，我们将缓存结果保存在磁盘上，以便在程序重启后仍然可以继续使用缓存的结果。我们还指定了show_spinner=False，以关闭加载指示器的显示。

experimental_rerun 用于立即重新运行脚本

Streamlit中的experimental_rerun函数用于立即重新运行脚本。当该函数被调用时，脚本会暂停执行，不再运行后续的语句，并且会排队等待从顶部重新运行。

这个函数在Streamlit的实验性功能中，可能会在未来的版本中有所改变。因此，在使用时需要谨慎，并注意检查更新和文档以获取最新的信息。

如果在Streamlit之外调用此函数，它将引发异常。因此，建议在Streamlit应用程序中使用此函数，以确保脚本的正确执行。

experimental_set_query_params 用于设置URL查询参数

Streamlit中的experimental_set_query_params函数用于设置URL查询参数。这个函数接受一个字典作为参数，该字典包含了要设置的查询参数及其对应的值。

示例代码：

import streamlit as st

# 设置查询参数
params = {"param1": "value1", "param2": "value2"}
st.experimental_set_query_params(params)
1
2
3
4
5

在这个示例中，我们首先导入了streamlit库，然后创建了一个包含查询参数和其对应值的字典。最后，我们调用st.experimental_set_query_params函数并将字典作为参数传递给它，以便设置URL查询参数。

experimental_singleton

Streamlit中的experimental_singleton函数是一个装饰器，用于将一个函数转换为单例对象。这意味着在应用程序的所有用户之间共享该函数实例，避免在每次调用时都重新创建新的函数实例。

示例代码：

import streamlit as st

@st.experimental_singleton
def my_function():
    # 这里是函数的实现
    pass
1
2
3
4
5
6

在这个示例中，我们使用@st.experimental_singleton装饰器来将my_function函数转换为单例对象。这意味着在整个Streamlit应用程序中，只有一个my_function实例存在，并且可以在不同的用户之间共享。

需要注意的是，experimental_singleton装饰器是实验性的，可能会在未来的版本中有所改变。因此，在使用时需要谨慎，并注意检查更新和文档以获取最新的信息。

file_uploader 文件上传工具

Streamlit中的file_uploader组件是一个方便的文件上传工具，支持拖拽上传文件和文件管理器选择文件。

使用方法如下：

style_file = st.file_uploader("请上传风格化图片")
if style_file:
    stringio = style_file.getvalue()
    style_file_path = 'style_file/'+ style_file.name
    with open(style_file_path,'wb') as f:
        f.write(stringio)
1
2
3
4
5
6

使用文件上传组件上传文件之后，可以使用上面的代码将文件保存到特定路径等待使用。

form 用于收集用户输入的组件

Streamlit中的form是一种用于收集用户输入的组件。当用户填写表单并提交时，表单中的数据可以被批量发送到Streamlit。每个表单必须包含一个st.form_submit_button，而不能包含st.button或st.download_button。此外，表单可以出现在应用程序的任何位置（例如侧边栏、列等），但它们不能嵌入到其他表单中。

在创建表单时，可以使用st.form(key, clear_on_submit=False)函数。该函数接受一个关键字参数key，用于指定表单的唯一标识符。此外，还可以使用clear_on_submit参数指定在提交表单后是否清除表单数据。

在表单中添加元素时，可以使用st.form_element(label, element)函数。该函数接受两个参数：label用于指定元素的标签，element用于指定元素类型和参数。例如，要添加一个滑块组件，可以使用st.slider(label, min_value=None, max_value=None, value=None, step=None, format=None, key=None)函数。该函数接受一些参数，如最小值（min_value）、最大值（max_value）、当前值（value）、步长（step）等。

最后，为了提交表单，可以使用st.form_submit_button(label)函数。该函数接受一个参数label，用于指定提交按钮的标签。当用户点击提交按钮时，表单中的所有小部件值将被批量发送到Streamlit。

form_submit_button 用于提交表单的按钮

Streamlit中的form_submit_button是一个用于提交表单的按钮。当用户点击该按钮时，表单中的所有小部件（widget）值将被批量发送到Streamlit。每个表单都必须有一个form_submit_button，并且该按钮不能出现在表单之外。

form_submit_button函数可以接受一些可选参数，如label（用于指定提交按钮的标签）、help（用于指定帮助文本）、on_click（用于指定点击事件的处理函数）和args、kwargs（用于传递参数给处理函数）。

在表单中使用form_submit_button时，需要先创建一个表单，并添加需要的小部件。然后，在表单外使用form_submit_button来提交表单。当用户点击提交按钮时，Streamlit将自动收集表单中的所有小部件值，并将其发送到指定的处理函数中进行处理。

get_option 读取指定的配置项的值

Streamlit中的get_option函数用于读取指定的配置项的值。这个函数接受一个参数，即配置项的键（key），返回对应的配置项值。

例如，假设有一个配置项是"my_option"，对应的值是"value"，那么可以通过get_option函数来获取该配置项的值：

option_value = st.get_option("my_option")
print(option_value)  # 输出 "value"
1
2

可以使用st.set_option函数来设置配置项的值。例如，将"my_option"的配置项值设置为"new_value"：

st.set_option("my_option", "new_value")
1

这样，再次调用get_option函数时，将返回新的值：

option_value = st.get_option("my_option")
print(option_value)  # 输出 "new_value"
1
2

graphviz_chart 用于显示使用Graphviz库创建的图表

Streamlit中的graphviz_chart函数用于显示使用Graphviz库创建的图表。这个函数接受一个Graphviz图对象或dot字符串作为参数，并可以指定图表的宽度和高度。

要使用graphviz_chart函数，首先需要安装Graphviz库。可以使用以下命令在Python中安装Graphviz：

pip install graphviz
1

然后，可以使用graphviz_chart函数来显示Graphviz图表。下面是一个简单的示例代码：

import streamlit as st
import graphviz as gv

# 创建一个Graphviz图对象
dot = gv.Digraph(comment='The Round Table')
dot.node('A', 'King Arthur')
dot.node('B', 'Sir Bedevere the Wise')
dot.node('L', 'Sir Lancelot the Brave')
dot.edges(['AB', 'AL'])

# 使用graphviz_chart函数显示图表
st.graphviz_chart(dot)
1
2
3
4
5
6
7
8
9
10
11
12

在这个示例中，我们首先导入streamlit和graphviz库。然后，我们创建一个Graphviz图对象dot，并添加了三个节点和两个边。最后，我们使用graphviz_chart函数将dot对象显示为图表。

graphviz_chart函数还可以接受一些可选参数，如width和height，用于指定图表的宽度和高度。例如，下面的代码将图表宽度设置为400像素，高度设置为300像素：

st.graphviz_chart(dot, width=400, height=300)
1

header 显示标题文本

Streamlit中的header方法用于显示标题文本。它接受一个字符串参数，即要显示的标题文本。

示例代码如下：

import streamlit as st

st.header('This is a header')
1
2
3

这段代码会在Streamlit应用程序中显示标题文本“This is a header”。

help 显示指定对象的文档字符串

Streamlit中的help方法用于显示指定对象的文档字符串（docstring）。它接受一个对象作为参数，并返回该对象的docstring。

示例代码如下：

import streamlit as st
import pandas as pd

# 创建一个DataFrame对象
df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]})

# 使用help方法查看DataFrame的docstring
st.help(df)
1
2
3
4
5
6
7
8

这段代码会显示DataFrame的docstring，包括它的功能、参数和返回值等信息。

除了查看指定对象的docstring，help方法还可以用于查看Python内置函数或模块的docstring。例如：

import streamlit as st
import numpy as np

# 使用help方法查看numpy模块的docstring
st.help(np)
1
2
3
4
5

这段代码会显示numpy模块的docstring，包括它的功能、参数和返回值等信息。

image 显示图像

Streamlit中的image方法用于显示图像。它接受一个图像对象或图像URL作为参数，并可以指定图像的标题和其他可选参数。

示例代码如下：

import streamlit as st

# 指定图像对象
image = st.image([image_data], caption='This is an image')

# 指定图像URL
image = st.image('https://example.com/image.jpg', caption='This is an image')
1
2
3
4
5
6
7

在这段代码中，image_data是一个包含图像数据的numpy数组，可以是单通道灰度图像（(w,h)或(w,h,1)）或多通道彩色图像（(w,h,3)或(w,h,4)）。如果图像数据太大，可以使用st.image方法指定图像数据的URL。

除了caption参数外，image方法还可以接受其他可选参数，如width（指定图像宽度）、use_column_width（如果设置为True，则使用列宽作为图像宽度）、clamp（如果设置为True，则截断超出显示区域的图像数据）和channels（指定图像通道数，可以是’RGB’或’RGBA’）。

注意：使用Streamlit显示图像时，需要保证图像数据或URL是可访问的，否则无法显示图像。

info 显示提示信息

Streamlit中的info方法用于显示提示信息。它接受一个字符串参数，即要显示的提示信息。

示例代码如下：

import streamlit as st

st.info('This is a purely informational message')
1
2
3

这段代码会在Streamlit应用程序中显示提示信息“This is a purely informational message”。

json JSON数据解析和显示

在Streamlit中，JSON数据可以通过json.loads方法进行解析和显示。以下是一个简单的例子：

import streamlit as st
import json

# 假设我们有一个JSON字符串
json_str = '''
{
  "name": "John",
  "age": 30,
  "city": "New York"
}
'''

# 使用json.loads解析JSON字符串
parsed_json = json.loads(json_str)

# 在Streamlit应用中显示解析后的JSON数据
st.write(parsed_json)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

在这个例子中，我们首先导入了streamlit和json库。然后，我们定义了一个JSON字符串，其中包含了一些名字、年龄和城市的信息。我们使用json.loads方法解析了这个JSON字符串，将其转换成了Python字典。最后，我们使用st.write方法将解析后的JSON数据写入到Streamlit应用中。

需要注意的是，如果你想要显示一个包含多个JSON对象的列表，可以使用json.loads方法将整个列表解析为Python对象，然后使用循环语句遍历列表中的每个对象并显示它们。例如：

import streamlit as st
import json

# 假设我们有一个包含多个JSON对象的列表
json_list = '''[
  {
    "name": "John",
    "age": 30,
    "city": "New York"
  },
  {
    "name": "Jane",
    "age": 25,
    "city": "Chicago"
  }
]'''

# 使用json.loads解析JSON列表
parsed_json_list = json.loads(json_list)

# 在Streamlit应用中显示解析后的JSON数据列表
for obj in parsed_json_list:
    st.write(obj)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

latex 显示数学公式

在Streamlit中使用LaTeX语法显示数学公式，需要在LaTeX字符串前面加上“latex:”标签。例如，要在Streamlit应用中显示一个二次方程式，可以这样写：

import streamlit as st

# 显示LaTeX公式
st.latex(r'ax^2 + bx + c = 0')
1
2
3
4

在这个例子中，我们使用st.latex方法来显示一个LaTeX公式。在LaTeX公式字符串前面加上“latex:”标签，以便Streamlit能够正确地识别和渲染它。在这个例子中，我们使用LaTeX语法来显示一个二次方程式。

注意：使用st.latex方法时，需要在公式字符串中使用LaTeX语法，并且字符串前面加上“latex:”标签。

line_chart 显示折线图

Streamlit中的line_chart方法用于显示折线图。这个方法接受一个数据帧作为输入，并根据该数据帧创建折线图。以下是使用line_chart方法的一个简单示例：

import streamlit as st
import pandas as pd
import numpy as np

# 生成随机数据帧
np.random.seed(0)
data = pd.DataFrame(np.random.randn(20, 3), columns=['a', 'b', 'c'])

# 显示折线图
st.line_chart(data)
1
2
3
4
5
6
7
8
9
10

在这个例子中，我们首先使用NumPy生成了一个包含随机数的数据帧。然后，我们使用st.line_chart方法来显示这个数据帧的折线图。默认情况下，line_chart方法会根据数据帧的列和索引计算图表的规格，因此更容易用于许多“只是绘制此内容”方案。同时，它的可定制性较低。如果无法正确猜测数据特征，可以尝试使用st.altair_chart指定所需的图表。

markdown 显示Markdown格式的内容

Streamlit中的markdown方法可以用于在Streamlit应用中显示Markdown格式的内容。这个方法接受一个字符串作为参数，该字符串包含Markdown格式的文本。

例如，假设我们想要在Streamlit应用中显示一个包含标题和段落的Markdown文档。可以使用markdown方法来实现这个目标，具体代码如下：

import streamlit as st

# 使用markdown方法显示Markdown文档
st.markdown(
    '''
    # 标题
    ## 子标题
    段落文本...
    '''
)
1
2
3
4
5
6
7
8
9
10

在这个例子中，我们使用markdown方法将一个包含标题和段落的Markdown文档显示到Streamlit应用中。在Markdown文档字符串中，我们使用了#和##来分别表示一级标题和二级标题，并使用普通文本格式表示段落文本。

需要注意的是，使用markdown方法显示的Markdown文档不会被Streamlit应用所解析和渲染，它将以原始格式显示在应用中。

metric 显示指标性数据

Streamlit中的metric方法可以用于显示指标性数据。这个方法接受一个对象作为参数，该对象表示要显示的数据。

例如，假设我们想要在Streamlit应用中显示一个表示温度的度量。可以使用metric方法来实现这个目标，具体代码如下：

import streamlit as st
from streamlit_metrics import metric_row

# 定义一个度量对象
temperature = metric_row('Temperature', 70, delta=1.2)

# 使用metric方法显示度量数据
st.metric(temperature)
1
2
3
4
5
6
7
8

在这个例子中，我们首先使用metric_row函数创建了一个表示温度的度量对象。该函数的第一个参数是度量的标签，第二个参数是度量的当前值，第三个参数是度量的变化量（delta）。然后，我们使用metric方法将该度量对象显示到Streamlit应用中。

需要注意的是，使用metric方法显示的度量数据可以通过Streamlit应用进行更新和刷新。可以根据需要使用该方法来显示各种类型的指标性数据，例如温度、气压、高度等等。

multiselect 显示多选框组件

Streamlit中的multiselect方法可以用于显示多选框组件，让用户可以选择多个选项。

multiselect方法接受以下参数：

• label：选择框的说明文本。
• options：选项列表，可以包括以下类型：list（列表）、tuple（元组）、numpy.ndarray（NumPy数组）、pandas.Series（pandas序列）。
• default：默认选中的选项，如果没有默认选项，则可以传入一个空列表。
• format_func：用于格式化选项显示的函数，默认为str函数。
• key：多选框组件的ID，用于在Streamlit应用中识别该组件。

该方法返回用户选中的选项列表。

以下是一个使用multiselect方法的示例代码：

import streamlit as st

# 定义选项列表
options = ['Option 1', 'Option 2', 'Option 3', 'Option 4']

# 使用multiselect方法显示多选框组件
selected_options = st.multiselect('Choose options', options)

# 显示选中的选项
st.write('You selected:', selected_options)
1
2
3
4
5
6
7
8
9
10

在这个示例中，我们定义了一个选项列表options，然后使用multiselect方法显示了一个多选框组件。用户可以通过选择每个选项旁边的复选框来选择多个选项。最后，我们使用write方法显示了用户选中的选项。

number_input 显示数值输入框

Streamlit中的number_input方法可以用于显示数值输入框。

该方法接受以下参数：

• label：输入框的说明文本。
• min_value：允许的最小值，可以是整数或浮点数，也可以是None，表示没有最小值限制。
• max_value：允许的最大值，可以是整数或浮点数，也可以是None，表示没有最大值限制。
• value：输入框的当前值，如果没有默认值，则传入None。
• step：数值变化步长，默认为1或0.01。
• format：数值显示格式化字符串或None。

该方法返回输入组件的当前值。

以下是一个使用number_input方法的示例代码：

import streamlit as st

# 使用number_input方法显示数值输入框
value = st.number_input('Enter a number', min_value=0, max_value=100, value=50, step=1, format='.2f')

# 显示用户输入的值
st.write('You entered:', value)
1
2
3
4
5
6
7

在这个示例中，我们使用number_input方法显示了一个数值输入框。用户可以在输入框中输入一个介于0和100之间的数值，默认值为50。如果用户输入的值超出了允许的范围，则会提示用户重新输入。最后，我们使用write方法显示了用户输入的值。

plotly_chart 显示Plotly图表

Streamlit中的plotly_chart方法可以用于显示Plotly图表。

plotly_chart方法接受一个或多个Plotly图表对象作为参数，并将其显示在Streamlit应用中。该方法支持多种类型的Plotly图表，包括折线图、散点图、柱状图、饼图等。

以下是一个使用plotly_chart方法的示例代码：

import streamlit as st
import plotly.express as px

# 创建示例数据
data = px.data.iris()

# 使用plotly_chart方法显示折线图
st.plotly_chart(px.line(data, x="sepal_width", y="sepal_length", color="species"))
1
2
3
4
5
6
7
8

在这个示例中，我们使用Plotly Express模块创建了一个示例数据集，并使用plotly_chart方法显示了一个折线图。该折线图根据“sepal_width”和“sepal_length”列的数据绘制了不同品种鸢尾花的生长趋势。

需要注意的是，要使用plotly_chart方法，需要在Streamlit应用中导入Plotly库，并将其与Streamlit库一起使用。此外，还需要根据具体的Plotly图表类型和数据格式调用相应的Plotly函数来创建图表对象。

progress 显示进度条

Streamlit中的progress方法可以用于显示进度条。该方法可以根据完成进度来更新进度条的状态。

progress方法接受一个数值参数，范围为[0,100]，表示完成的百分比。通过调用progress方法并传入相应的百分比值，可以更新进度条的状态。

以下是一个使用progress方法的示例代码：

import streamlit as st

# 创建进度条
progress_bar = st.progress(0)

# 模拟一个耗时任务
for i in range(100):
    time.sleep(0.1)  # 模拟耗时任务
    progress_bar.progress(i + 1)  # 更新进度条状态
1
2
3
4
5
6
7
8
9

在这个示例中，我们首先创建了一个进度条对象progress_bar，初始进度为0。然后，我们模拟了一个耗时任务，通过循环100次，每次更新进度条的状态。在每次循环中，我们使用progress方法更新进度条的状态，传入当前完成的百分比值。

需要注意的是，进度条的状态只会在Streamlit应用中显示，并且每次更新进度条的状态都会导致页面刷新。因此，在更新进度条时需要注意性能和用户体验。

pydeck_chart 显示PyDeck图表

Streamlit中的pydeck_chart方法可以用于显示PyDeck图表。PyDeck是一个基于JavaScript的数据可视化库，支持多种地图和图表类型，并支持交互和放大缩小等操作。

pydeck_chart方法接受一个PyDeck图表对象作为参数，并将其显示在Streamlit应用中。该方法支持多种类型的PyDeck图表，包括散点图、柱状图、热力图等。

以下是一个使用pydeck_chart方法的示例代码：

import streamlit as st
import pydeck as pdk

# 创建PyDeck图表对象
view = pdk.View(pdk.ScatterplotLayer, deck_options=pdk.DeckOptions(initial_view_state=pdk.ViewState(latitude=37.769999612954, longitude=-122.446293375463, zoom=10)))

# 使用pydeck_chart方法显示图表
st.pydeck_chart(view)
1
2
3
4
5
6
7
8

在这个示例中，我们首先创建了一个PyDeck图表对象view，它使用了一个ScatterplotLayer来显示散点图。然后，我们使用pydeck_chart方法将该图表显示在Streamlit应用中。

需要注意的是，要使用pydeck_chart方法，需要在Streamlit应用中导入PyDeck库，并将其与Streamlit库一起使用。此外，还需要根据具体的PyDeck图表类型和数据格式调用相应的PyDeck函数来创建图表对象。

pyplot

Streamlit中的pyplot方法可以用于显示Matplotlib图表。Matplotlib是一个Python数据可视化库，支持多种类型的图表和绘图方式。

pyplot方法接受一个Matplotlib图表对象作为参数，并将其显示在Streamlit应用中。该方法支持多种类型的Matplotlib图表，包括折线图、散点图、柱状图、饼图等。

以下是一个使用pyplot方法的示例代码：

import streamlit as st
import matplotlib.pyplot as plt

# 创建Matplotlib图表对象
fig, ax = plt.subplots()
ax.plot([1, 2, 3, 4], [1, 4, 2, 3])
plt.show()

# 使用pyplot方法显示图表
st.pyplot(fig)
1
2
3
4
5
6
7
8
9
10

在这个示例中，我们首先使用Matplotlib创建了一个折线图对象fig，并通过plot方法绘制了一条简单的折线。然后，我们使用show方法将图表显示出来。最后，我们使用pyplot方法将该图表显示在Streamlit应用中。

需要注意的是，要使用pyplot方法，需要在Streamlit应用中导入Matplotlib库，并将其与Streamlit库一起使用。此外，还需要根据具体的Matplotlib图表类型和数据格式调用相应的Matplotlib函数来创建图表对象。

radio 单选按钮小部件

Streamlit中的radio方法可以用于显示单选按钮小部件。该方法接受一个label参数，用于向用户解释此单选按钮组的用途，以及一个options参数，用于定义可用的选项列表。

例如：

import streamlit as st

# 定义选项列表
options = ['Option 1', 'Option 2', 'Option 3', 'Option 4']

# 使用radio方法显示单选按钮小部件
selected_option = st.radio('Choose an option', options)

# 显示选中的选项
st.write('You selected:', selected_option)
1
2
3
4
5
6
7
8
9
10

在这个例子中，我们定义了一个选项列表options，然后使用radio方法显示了一个单选按钮小部件。用户可以在该小部件中选择一个选项，然后通过点击“运行”按钮来确认选择。最后，我们使用write方法显示了用户选中的选项。

selectbox 显示下拉选择框组件

Streamlit中的selectbox方法可以用于显示下拉选择框组件。该方法接受一个label参数，用于向用户解释此下拉选择框的用途，以及一个options参数，用于定义可用的选项列表。

例如：

import streamlit as st

# 定义选项列表
options = ['Option 1', 'Option 2', 'Option 3', 'Option 4']

# 使用selectbox方法显示下拉选择框
selected_option = st.selectbox('Choose an option', options)

# 显示选中的选项
st.write('You selected:', selected_option)
1
2
3
4
5
6
7
8
9
10

在这个例子中，我们定义了一个选项列表options，然后使用selectbox方法显示了一个下拉选择框。用户可以从该选择框中选择一个选项，然后通过点击“运行”按钮来确认选择。最后，我们使用write方法显示了用户选中的选项。

set_option 用于设置指定配置项的值

Streamlit中的set_option方法用于设置指定配置项的值。这个方法接受两个参数：配置项的键（key）和配置项的值（value）。

可以通过运行streamlit config show查看所有可用的配置项。

这是一个使用set_option的例子：

import streamlit as st

# 设置配置项的值
st.set_option('my_config_option', 'my_value')
1
2
3
4

在这个例子中，我们设置了名为my_config_option的配置项的值为my_value。

同时，你也可以使用st.get_option方法来读取配置项的值。例如：

import streamlit as st

# 读取配置项的值
value = st.get_option('my_config_option')

# 显示配置项的值
st.write('The value of my_config_option is:', value)
1
2
3
4
5
6
7

在这个例子中，我们读取了名为my_config_option的配置项的值，并使用st.write方法显示出来。

set_page_config

Streamlit中的set_page_config方法可以用于设置页面配置，例如页面标题、页面样式等。这个方法接受一个字典参数，可以在字典中指定多个配置项。

以下是一个使用set_page_config的示例：

import streamlit as st

# 设置页面配置
st.set_page_config(
    page_title='My Streamlit App',
    page_icon='logo.png',
    header_font_name='Arial',
    header_font_size=18,
    primary_color='blue',
    script_tag='<script>console.log("Hello, world!");</script>'
)
1
2
3
4
5
6
7
8
9
10
11

在这个示例中，我们使用set_page_config方法设置了页面标题、页面图标、头部字体名称、头部字体大小、主色调以及一个脚本标签。这些配置项可以根据需要进行调整和修改。

slider 显示滑块小部件

Streamlit是一种开源的Python库，它可以帮助开发者轻松地构建交互式Web应用。在Streamlit应用中，你可以使用slider组件来创建一个滑块，用户可以通过移动滑块来选择一个值。

下面是一个简单的例子，演示如何在Streamlit应用中创建一个滑块：

import streamlit as st

# 设置滑块的标签和范围
st.write("你可以选择一个值：")

# 创建一个滑块，初始值为5，范围在1到10之间
slider_value = st.slider('选择一个值', min_value=1, max_value=10, value=5)

# 显示用户选择的滑块值
st.write(f"你选择的值为：{slider_value}")
1
2
3
4
5
6
7
8
9
10

在这个例子中，我们首先导入了streamlit库。然后，我们使用st.write函数来显示一段文本和一个滑块。st.slider函数接受几个参数：滑块的标签、最小值、最大值和初始值。当用户移动滑块并选择一个值时，这个值将作为滑块的值返回，我们可以使用这个值来更新应用的状态或执行其他操作。最后，我们使用st.write函数来显示用户选择的滑块值。

snow 绘制庆祝降雪

一个下雪的动画

st.snow()
1

spinner 在执行代码块时临时显示一条消息

Streamlit中的spinner是一种在执行代码块时显示状态信息的功能。它可以帮助用户了解程序正在处理任务，而不是无响应或卡住。

要使用spinner，您可以在代码块之前使用st.spinner函数来创建一个spinner对象，然后在代码块结束之前调用spinner.stop()方法来停止spinner。

下面是一个使用Streamlit spinner的示例代码：

import streamlit as st
import time

# 创建spinner对象
spinner = st.spinner('正在处理中...')

# 执行代码块
time.sleep(5)

# 停止spinner
spinner.stop()

# 显示成功消息
st.success('处理完成！')
1
2
3
4
5
6
7
8
9
10
11
12
13
14

在这个例子中，我们首先使用st.spinner函数创建了一个spinner对象，并在对象上调用start()方法来启动spinner。然后，我们使用time.sleep函数模拟了一个耗时的操作。在操作结束后，我们调用spinner.stop()方法停止spinner，并使用st.success函数显示一个成功消息。

stop 立即停止执行

在Streamlit中，stop是spinner对象的一个方法，用于停止旋转的加载符号。

当您在Streamlit应用中执行一个耗时的操作时，可以使用spinner对象来显示一个加载符号，以向用户显示该操作正在进行中。在操作完成后，您可以使用stop方法来停止加载符号的旋转，并显示一个消息或结果。

以下是一个简单的示例代码，演示了如何使用Streamlit中的spinner对象和stop方法：

import streamlit as st
import time

# 创建spinner对象
spinner = st.spinner('正在处理中...')

# 执行耗时的操作
time.sleep(5)

# 停止spinner
spinner.stop()

# 显示成功消息
st.success('处理完成！')
1
2
3
4
5
6
7
8
9
10
11
12
13
14

在这个例子中，我们首先创建了一个spinner对象，并在对象上调用start()方法来启动加载符号的旋转。然后，我们使用time.sleep函数模拟了一个耗时的操作。在操作结束后，我们调用stop方法来停止加载符号的旋转，并使用st.success函数显示一个成功消息。

subheader 以子标题格式显示文本

在Streamlit中，subheader是一个用于创建子标题的函数。它可以帮助您在应用中添加额外的层次结构，以便更好地组织和展示内容。

要使用subheader函数，您可以在Streamlit的代码块中使用以下语法：

st.subheader('子标题内容')
1

下面是一个简单的示例，演示了如何在Streamlit应用中使用subheader函数：

import streamlit as st

# 创建主标题
st.header('我的Streamlit应用')

# 创建子标题
st.subheader('子标题内容')

# 添加其他内容
st.write('这是一些额外的内容')
1
2
3
4
5
6
7
8
9
10

在上面的示例中，我们首先使用st.header函数创建了一个主标题。然后，我们使用st.subheader函数创建了一个子标题。最后，我们使用st.write函数添加了一些其他内容。

当您运行这个Streamlit应用时，您将看到主标题和子标题显示在页面的顶部。子标题将显示在主标题下方，并且字体和样式稍小一些，以突出显示其层次结构的位置。

success 显示成功消息

在Streamlit框架中，success是一种展示成功信息的方式。你可以通过st.success(body)函数来实现，其中body参数是你想要展示的成功信息文本。例如，st.success('This is a success message!')会在应用中显示一条名为"This is a success message!"的成功信息。

table 显示静态表

Streamlit中的table组件可以用来显示数据表格。你可以使用st.table(df)来创建一个表格，其中df是一个包含数据的pandas DataFrame对象。

下面是一个简单的例子：

import pandas as pd
import streamlit as st

# 创建一个数据框
data = {'Name': ['Alice', 'Bob', 'Charlie'],
        'Age': [25, 30, 35],
        'City': ['New York', 'San Francisco', 'Los Angeles']}
df = pd.DataFrame(data)

# 显示数据框
st.table(df)
1
2
3
4
5
6
7
8
9
10
11

在这个例子中，我们首先创建了一个包含姓名、年龄和城市的pandas DataFrame对象。然后，我们使用st.table函数来显示这个数据框。当你在Streamlit应用中运行这段代码时，你会看到一个包含姓名、年龄和城市的表格。

tabs 插入分隔成标签的容器

Streamlit中的tabs组件可以用来创建标签页。你可以使用st.tabs([tab1, tab2, tab3])来创建一个包含多个标签页的应用，其中tab1、tab2和tab3是标签页的标题。

下面是一个简单的例子：

import streamlit as st

# 创建标签页
tab1 = st.tab("标签1")
tab2 = st.tab("标签2")

# 在标签页中添加内容
with tab1:
    st.write("这是标签1的内容")
with tab2:
    st.write("这是标签2的内容")
1
2
3
4
5
6
7
8
9
10
11

在这个例子中，我们首先使用st.tabs函数创建了一个包含两个标签页的应用。然后，我们使用st.tab函数创建了两个标签页，分别是"标签1"和"标签2"。最后，我们在每个标签页中添加了不同的内容。当你在Streamlit应用中运行这段代码时，你会看到一个包含两个标签页的应用，每个标签页中显示了不同的内容。

text 写固定宽度和预格式化的文本

在Streamlit框架中，text方法用于显示文本内容。你可以使用st.text(body)来在应用中显示文本，其中body参数是要显示的文本内容。

下面是一个简单的例子：

import streamlit as st

# 显示文本内容
st.text("这是一段文本内容")
1
2
3
4

在这个例子中，我们使用st.text函数来显示一段文本内容。当你在Streamlit应用中运行这段代码时，你会看到指定的文本内容显示在应用中。

text_area 显示多行文本输入小部件

Streamlit中的text_area方法可以用来创建一个多行文本输入框。这个方法接受一个字符串作为初始文本，并允许用户在文本框内进行编辑和修改。

以下是使用text_area方法创建多行文本输入框的示例代码：

import streamlit as st

# 创建一个多行文本输入框
text = "请输入您的文本内容"
textarea_result = st.text_area(label="输入框", value=text)

# 显示用户输入的文本
st.write(f"您输入的文本是：{textarea_result}")
1
2
3
4
5
6
7
8

在这个例子中，我们使用st.text_area方法创建了一个标签为"输入框"的多行文本输入框，并将字符串"请输入您的文本内容"作为初始文本。用户可以在这个文本框内编辑和输入自己的文本。然后，我们将用户输入的文本用st.write方法显示出来。

当你在Streamlit应用中运行这段代码时，你会看到一个多行文本输入框，你可以在框内编辑和输入文本。输入的文本将被保存在textarea_result变量中，并在应用中显示出来。

text_input 显示单行文本输入小部件

Streamlit中的text_input方法可以用来创建一个单行文本输入框。这个方法接受一个字符串作为初始文本，并允许用户在文本框内进行编辑和修改。

以下是使用text_input方法创建单行文本输入框的示例代码：

import streamlit as st

# 创建一个单行文本输入框
label = "输入框"
value = ""
text_input_result = st.text_input(label, value=value)

# 显示用户输入的文本
st.write(f"您输入的文本是：{text_input_result}")
1
2
3
4
5
6
7
8
9

在这个例子中，我们使用st.text_input方法创建了一个标签为"输入框"的单行文本输入框，并将空字符串""作为初始文本。用户可以在这个文本框内编辑和输入自己的文本。然后，我们将用户输入的文本用st.write方法显示出来。

当你在Streamlit应用中运行这段代码时，你会看到一个单行文本输入框，你可以在框内编辑和输入文本。输入的文本将被保存在text_input_result变量中，并在应用中显示出来。

time_input 显示时间输入小部件

Streamlit中的time_input方法可以用来创建一个时间输入框。这个方法接受一个字符串作为初始文本，并允许用户在文本框内选择一个时间值。

以下是使用time_input方法创建时间输入框的示例代码：

import streamlit as st

# 创建一个时间输入框
label = "选择时间"
initial_time = "12:00 PM"
time_input_result = st.time_input(label, value=initial_time)

# 显示用户选择的时间
st.write(f"您选择的时间是：{time_input_result}")
1
2
3
4
5
6
7
8
9

在这个例子中，我们使用st.time_input方法创建了一个标签为"选择时间"的时间输入框，并将字符串"12:00 PM"作为初始时间值。用户可以在这个文本框内选择一个不同的时间值，然后我们将用户选择的时间值用st.write方法显示出来。

当你在Streamlit应用中运行这段代码时，你会看到一个时间输入框，你可以在框内选择一个时间值。选择的时间将被保存在time_input_result变量中，并在应用中显示出来。

title 以标题格式显示文本

Streamlit中的title方法可以用来显示应用标题。这个方法接受一个字符串作为参数，用于设置应用的主标题。

以下是使用title方法显示应用标题的示例代码：

import streamlit as st

# 设置应用标题
st.title("我的Streamlit应用")

# 其他操作和应用内容...
1
2
3
4
5
6

在这个例子中，我们使用st.title方法将应用标题设置为"我的Streamlit应用"。当你在Streamlit应用中运行这段代码时，你会在应用顶部看到设置的标题。

需要注意的是，每个Streamlit应用最多只能有一个标题设置，但并不是强制要求每个应用都必须设置标题。如果你不设置标题，Streamlit不会显示任何标题文本。

vega_lite_chart 使用Vega-Lite库显示图表

Streamlit中的vega_lite_chart方法使用Vega-Lite库来显示指定的图表。该方法接受以下参数：

• data：要显示的数据对象或Vega-Lite图表规格。数据类型可以是pandas DataFrame、pandas Styler、numpy ndarray、Iterable或None。如果data参数已经传入图表规格，那么spec参数必须传入None。
• spec：Vega-Lite的图表规格。如果在前面data参数已经传入图表规格，这里必须传入None。
• width：宽度模式。0表示使用整个文档宽度，-1表示使用Vega-Lite的默认值，大于0表示要设置的宽度像素。

以下是一个简单的示例代码，演示了如何使用vega_lite_chart方法显示一个柱状图：

import streamlit as st
import pandas as pd
import vega_lite as vl

# 创建数据
data = {'x': ['A', 'B', 'C', 'D'],
        'y': [10, 20, 30, 40]}
df = pd.DataFrame(data)

# 创建Vega-Lite图表规格
spec = vl.Specification({
    'encoding': {
        'x': {
            'type': 'category',
            'values': df['x']
        },
        'y': {
            'type': 'quantitative',
            'scale': {'domain': [0, 100]}
        }
    },
    'data': [df],
    'config': {'view': {
        'width': 400,
        'height': 300}}
})

# 显示柱状图
st.vega_lite_chart(data=df, spec=spec, width=400)
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

在这个例子中，我们首先创建了一个包含数据和Vega-Lite图表规格的数据框df和spec。然后，我们使用st.vega_lite_chart方法来显示这个柱状图。我们将数据框df和图表规格spec作为参数传递给该方法，并设置宽度模式为400像素。当你在Streamlit应用中运行这段代码时，你会看到一个包含数据的柱状图。

video 显示视频播放器

Streamlit中的video方法可以用来播放视频。这个方法接受一个字节码流（BytesIO）或numpy.ndarray对象作为参数，用于指定要播放的视频数据。此外，还可以设置视频的MIME类型和开始播放的时间。

以下是使用video方法播放视频的示例代码：

import streamlit as st
import numpy as np
import io

# 读取视频文件并转换为字节码流
with open('myvideo.mp4', 'rb') as video_file:
    video_bytes = video_file.read()

# 播放视频
st.video(video_bytes)
1
2
3
4
5
6
7
8
9
10

在这个例子中，我们首先使用open函数打开一个名为myvideo.mp4的视频文件，并使用read方法读取文件内容到字节码流对象video_bytes中。然后，我们使用st.video方法将这个字节码流传递给Streamlit，以播放这个视频。当你在Streamlit应用中运行这段代码时，你会看到一个视频播放器，其中会播放你指定的视频。

需要注意的是，要确保指定的视频文件是可访问的，并且字节码流对象的数据格式正确。另外，由于Streamlit会将视频数据传递给浏览器进行播放，因此视频的格式和编码方式需要符合浏览器的要求。如果遇到任何问题，可以尝试将视频转换为不同的格式或使用其他视频播放库进行尝试。

warning 显示警告信息

Streamlit中的warning方法用于显示警告信息。这个方法接受一个字符串作为参数，用于指定要显示的警告信息。

以下是使用warning方法显示警告信息的示例代码：

import streamlit as st

# 显示警告信息
st.warning('这是一个警告信息')
1
2
3
4

在这个例子中，我们使用st.warning方法传递一个字符串'这是一个警告信息'作为参数，以显示警告信息。当你在Streamlit应用中运行这段代码时，你会看到一个警告框，其中包含指定的警告信息。

write 向应用程序写入参数。

Streamlit中的write方法用于在应用中显示文本、数据、图表等不同类型的内容。这个方法可以接受多个参数，包括字符串、DataFrame、字典、Matplotlib图表等各种类型的数据。

以下是使用write方法显示不同类型数据的示例代码：

import streamlit as st
import pandas as pd
import matplotlib.pyplot as plt

# 显示格式化的Markdown字符串
st.write('这是Markdown格式的字符串')

# 显示表格形式的Pandas DataFrame对象
data = {'Name': ['Alice', 'Bob', 'Charlie'],
        'Age': [25, 30, 35]}
df = pd.DataFrame(data)
st.write(df)

# 显示字典对象的内容
dict_data = {'Name': 'Alice', 'Age': 25}
st.write(dict_data)

# 显示Matplotlib图表
plt.plot([1, 2, 3], [4, 5, 6])
st.write(plt.gcf())
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

在这个例子中，我们首先使用st.write方法显示一个格式化的Markdown字符串。然后，我们创建了一个包含姓名和年龄数据的Pandas DataFrame对象，并使用st.write方法将其显示为表格形式。接下来，我们创建了一个包含姓名和年龄数据的字典对象，并使用st.write方法将其内容显示出来。最后，我们使用Matplotlib库绘制了一个简单的折线图，并使用st.write方法将图表显示出来。当你在Streamlit应用中运行这段代码时，你会看到应用中依次显示了Markdown字符串、表格、字典内容和Matplotlib图表。