python学习

flask全局变量三，视图间的参数传递

在”flask全局变量一“，时，我讲了采用session[“变量名”]，来定义全局变量，实现在视图间传递变量。现在用用另一名方法，用上下文的方法，采用g变量，来定义全局变量。比方法一要简单
有几个上下文装饰器
装饰器名 方式
@app.before_request 函数会在请求处理之前被调用
@app.after_request 函数会在请求处理完成后才被调用
@app.teardown_request 函数会在请求处理完成后才被调用 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
from flask import Flask
from flask import g, request

app=Flask(__name__)

@app.before_request
def span_num_init():
	g.start_num = 0 # 定义g变量
	g.span_mum = 5 # 定义g变量

@app.route("/fun1")
def fun1():
    g.start_num=9
    g.span_num=16

@app.route("/fun2")
def fun2():
    print("start_num=",g.start_num) # 此处start_num又变为0
    print("span_num=",g.span_num]) # 此处start_num又变为5

python学习

flask全局变量二，自定义上下文参数

如果我要在模板中一个多选菜单的项目是个变量。那么要每个视图函数读一次变量，再发送到模版中去。比如：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
def get_option_item():
    item = ["项目1"，"项目2"，"项目3"，"项目4"，"项目5"，"项目6"，"项目7"，]
    return item
#视图1
@app.route(/index1)
def index1():
    item=get_option_item()
    return render_template("index1.html", item=itme)
....
#视图n
@app.route(/index_n)
def index_n():
    item=get_option_item()
    return render_template("indexn.html", item=itme)

在模板中

1
2
3
4
5
<select>
    {% for select_i in item %}
    <option> select_i </option>
    {% endfor %}
</select>
每个视图要读一次很烦，那么采用上下文变量的方式就很好的解决了这个问题。修改一下python代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# current_app对象是一个定义在应用上下文中的代理
from flask import current_app
app=Flask(__name__)

# 函数用@app.context_processor装饰器修饰，它是一个上下文处理器，它的作用是在模板被渲染前运行其所修饰的函数，并将函数返回的字典导入到模板上下文环境中，与模板上下文合并。
@app.context_processor
def get_option_item():
    item = ["项目1"，"项目2"，"项目3"，"项目4"，"项目5"，"项目6"，"项目7"，]
    return dict(item=item) #注意是字典
# 视图函数不用再调用了
#视图n
@app.route(/index_n)
def index_n():
    # item=get_option_item()
    return render_template("indexn.html")
模板不用改变，直接就可用了。
python学习

streamlit学习笔记五-----多个小部件分组

默认情况下，每次用户与您的streamlit应用（表单）交互时，Streamlit 都会重新运行您的脚本。然而，有时在实际重新运行脚本之前等待一组相关的小部件（表单项）被填充完后，再执行更好，这里st.form()诞生了。

格式

st.form(key: str, clear_on_submit: bool = False)
key: 字符串，表示这个表单的标识
clear_on_submit：布而值，如果为 True，则在用户按下提交按钮后，表单内的所有小部件都将重置为其默认值。

一 with用法
1
2
3
4
5
6
7
8
9
10
11
12
with st.form("my_form"):
    st.write("Inside the form")
    slider_val = st.slider("Form slider")
    checkbox_val = st.checkbox("Form checkbox")

    # 每一个form必须有一个 submit 按钮.
    submitted = st.form_submit_button("Submit")
    if submitted:
        st.write("slider", slider_val, "checkbox", checkbox_val)

st.write("己通退了表单j")

二 指名用法
1
2
3
4
5
6
7
8

form23 = st.form("my_form")
form23.slider("Inside the form")
st.slider("在此表单外面了")

# 增加一个submit按钮到此表单:
form23.form_submit_button("Submit")

python学习

flask 的form学习之三，一个小form 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class MockCreate(Form):
    user_email = StringField("email address",[validators.Email()])
    api = StringField("api",[Required()])
    submit = SubmitField("Submit")
    code = IntegerField("code example: 200",[Required()])
    alias = StringField("alias for api")
    data = TextAreaField("json format",[Required()])


@app.route("/mockservice",methods=['GET','POST'])
def MockController():
    form = MockCreate()
    code = form['code']
    api = form['api']
    return render_template("testf.html",api=api,data=code)
python学习

flask全局变量一，视图间的参数传递

提出的问题：

flask视图间如何传递变量呢？开始我用的全局变量，如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
from flask import Flask,request,render_template

app=Flask(__name__)

app.secret_key = '就得是要一个key'   # 必须有
app.config['SESSION_TYPE'] = 'filesystem' # 必须有

start_num=0
span_num=5

@app.route("/fun1")
def fun1():
    start_num=9
    span_num=16

@app.route("/fun2")
def fun2():
    print("start_num=",start_num) #此处start_num又变为0
    print("span_num=",span_num]) #此处start_num又变为5

在执行视图fun2时, session[“start_num”]与session[“span_num”]的值又变为初始值了。
咋整呢？

网上找到一种办法是 session法。修改代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
from flask import Flask,request,render_template
from flask import session

app=Flask(__name__)

app.secret_key = '我的key'
app.config['SESSION_TYPE'] = 'filesystem'

session["start_num"]=0
session["span_num"]=5

@app.route("/fun1")
def fun1():
    session["start_num"]=9
    session["span_num"]=16

@app.route("/fun2")
def fun2():
    print("session["start_num"]",session["start_num"]) #此处session["start_num"]又变为9
    print("session["span_num"]",session["span_num"]) #此处session["start_num"]又变为16
还有一种办法就是把两个临时值传到数据库，或保存为json数据，存入文件中，程序不难，但是如果参数频繁改变的话，要反复读写文件就不好玩了。
python学习

flask 的form学习之二，Flask-WTF

使用 Flask-WTF的好处是直接在python中定义表单中的字段，比较直观

1
$ pip install flask-WTF

一. WTForms支持的全部HTML标准字段

字段对象 说明 相当于html的语句
StringField 文本字段
TextAreaField 多行文本字段
PasswordField 密码字段
HiddenField 隐藏文件字段
DateField 文本字段，值为datetime.date文本格式
DateTimeField 文本字段，值为datetime.datetime文本格式
IntegerField 文本字段，值为整数
DecimalField 文本字段，值为decimal.Decimal数
FloatField 文本字段，值为浮点数
BooleanField 复选框，值为True或False <input type=”radio”
RadioField 一组单选框
SelectField 下接列表
SelecMultipleField 可选择多个值的下接列表
FileField 文件上传
SubmitField 表单提交按钮
FormField 把表单做为字段嵌入另一个表单
FieldList 一组指定类型的字段

二 python代码

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
from flask import Flask
from flask import render_template
from flask_wtf import FlaskForm
from wtforms.fields import (StringField, PasswordField, DateField, BooleanField,
                            SelectField, SelectMultipleField, TextAreaField,
                            RadioField, IntegerField, DecimalField, SubmitField)
from wtforms.validators import DataRequired, InputRequired, Length, Email, EqualTo, NumberRange


app = Flask(__name__)
app.secret_key = 'asdfs'


class WtfForm(FlaskForm):
    # StringField 文本输入框，必填，用户名长度为4到25之间，占位符
    username = StringField('用户名：', validators=[Length(min=4, max=25)], render_kw={'placeholder': '请输入用户名'})

    # Email格式
    email = StringField('邮箱地址：', validators=[Email()], render_kw={'placeholder': '请输入邮箱地址'})

    # PasswordField，密码输入框，必填
    password = PasswordField('密码：', validators=[DataRequired()], render_kw={'placeholder': '请输入密码'})

    # 确认密码，必须和密码一致
    password2 = PasswordField('确认密码：', validators=[InputRequired(), EqualTo('password', '两次密码要一致')])

    # IntegerField，文本输入框，必须输入整型数值，范围在16到70之间
    age = IntegerField('年龄：', validators=[NumberRange(min=16, max=70)])

    # DecimalField，文本输入框，必须输入数值，显示时保留一位小数
    height = DecimalField('身高(cm):', places=1)

    # DateField，文本输入框，必须输入是"年-月-日"格式的日期
    birthday = DateField('出生日期：', format='%Y-%m-%d')

    # RadioField，单选框，choices里的内容会在ul标签里，里面每个项是(值，显示名)对
    gender = RadioField('性别：', choices=[('0', '男'), ('1', '女')], validators=[DataRequired()])

    # SelectField，下拉单选框，choices里的内容会在Option里，里面每个项是(值，显示名)对
    job = SelectField('职业：', choices=[
        ('teacher', '教师'),
        ('doctor', '医生'),
        ('engineer', '工程师'),
        ('lawyer', '律师')
    ])

    # Select类型，多选框，choices里的内容会在Option里，里面每个项是(值，显示名)对
    hobby = SelectMultipleField('爱好：', choices=[
        ('0', '吃饭'),
        ('1', '睡觉'),
        ('2', '敲代码')
    ])

    # TextAreaField，段落输入框
    description = TextAreaField('自我介绍：', validators=[InputRequired()], render_kw={'placeholder': '例：小明，18岁，未婚找女友'})

    # BooleanField，Checkbox类型，加上default='checked'即默认是选上的
    accept_terms = BooleanField('是否接受上述条款', default='checked', validators=[DataRequired()])

    # SubmitField，Submit按钮
    submit = SubmitField('提交')


@app.route('/', methods=['POST', 'GET'])
def index():
    form = WtfForm()
    return render_template('wtf.html', form=form)

if __name__ == "__main__":
    app.run(debug=True)

三. html代码

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
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<form action="">
    {{ form.csrf_token }}
    {{ form.username.label }}{{ form.username }}
    <br>
    {{ form.email.label }}{{ form.email }}
    <br>
    {{ form.password.label }}{{ form.password }}
    <br>
    {{ form.password2.label }}{{ form.password2 }}
    <br>
    {{ form.age.label }}{{ form.age }}
    <br>
    {{ form.height.label }}{{ form.height }}
    <br>
    {{ form.birthday.label }}{{ form.birthday }}
    <hr>
    {{ form.gender.label }}{{ form.gender }}
    <br>
    {{ form.job.label }}{{ form.job }}
    <br>
    {{ form.hobby.label }}{{ form.hobby }}
    <br>
    {{ form.description.label }}{{ form.description }}
    <br>
    {{ form.accept_terms.label }}{{ form.accept_terms }}
    <br>
    {{ form.submit }}
    <br>

</form>
</body>
</html>

python学习

flask 的form学习之一，传统form

传统的方法与php一样，先在html里建立form,并用action指向视图函数处理，并用POST方法传递参数。不多说，代码说明。

一. html文件 form.html
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<!DOCTYPE html>
<html lang="zh">
    <head>
        <meta charset="UTF-8" >
        <title>表单示便</title>
    </head>
    <body>
        <form action="regist",method="POST" >
            用户名:<input type="text",name="username"><br>
            密码:<input type="text",name="pawd"><br>
            再次密码：:<input type="text",name="re-pawd"><br>
            <input type="submit",value="注册"><br>
        </form>
    </body>
</html>
二. python代码中的视图函数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
from flask import Flask,request,render_template

app=Flask(__name__)

@app.route(/)
def index():
    return render_template("index.html")

@app.route("regist")
def regist():
    if request.method=="GET":
        return render_template("regist.html") # 没有输入的样子就是这个。
    if request.methom=="POST":
        uname=request.form.get("username")
        password=request.form.get("pawd")
        re_password=request.form.get("re-pawd")
    #下面添加处理语句

if __name__=="__main__":
    app.debug=True
    app.run(host = '127.0.0.1',port = 8080 )

python学习

flask打开Excel文件，并传给luckysheet显示

flask是个很好的网站框架，luckysheet的是一个很好的采用JS编写的表格框架，由于我一直采用flask，没有学习过javascript，所以想利用方便的lucksheet，如何结合呢？

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
#coding:utf8
from flask import Flask
from flask import request,render_template
import pandas as pd
import numpy as np
# from werkzeug import secure_filename
import os

app=Flask(__name__)

# 以下函数把一个excel表格读出，然后把数据转换成luckysheet的celldata，以便采用luckysheet显示在网页上
def pands_to_luckysheet(file_name):
	sheet_data=[] # 定义一个空列表

	data_f = pd.read_excel(file_name)

	none_nan=(data_f.isnull()) | (data_f.apply(lambda x: str(x).isspace())) # 找到所有的None
	data_f=data_f[~none_nan] # 把所有的None替换为nan
	# print("data_f2=",data_f)
	data_f=data_f.fillna("")  # 把所有的nan替换为空字符
	# print("data_f3=",data_f)	
	row=len(data_f) # 行数
	col=len(data_f.columns)  #列数
	# 打算把数据转换为luckysheet的celldata数据
	for i in range(row):
		for j in range(col):
			# sheet_data[k]=[{"r":i,"c":j,"v":{"v":data_f.iloc[i,j]}}]
			# k=k+1
			sheet_data.append({"r":i,"c":j,"v":{"v":data_f.iloc[i,j],"m":data_f.iloc[i,j]}}) # 添加列表项
	return sheet_data
	# print("测试luckckyshee数据转换")  
	# print(sheet_data)	

@app.route("/table_channel")
def table_channel():
	sheet_data=pands_to_luckysheet("/home/mywork/2021/汇总.xlsx")
	# print("sheet_data=",sheet_data)
	return render_template("index.html" ,lucky_data=sheet_data)

python学习

streamlit学习笔记四-----暂称为组件吧

创建静态组件

如果您创建 Streamlit 组件的目标仅仅是显示 HTML 代码或从 Python 可视化库中呈现图表，Streamlit 提供了两种方法来极大地简化流程：components.html() 和 components.iframe()。

  1. 渲染一个 HTML 字符串用： 

    1
    streamlit.components.v1.html(html, width=None, height=None, scrolling=False)

    html (str) – 要嵌入 iframe 的 HTML 字符串。注意是字符串，如果是文件名，则会出错

width (int) – 以 CSS 像素为单位的框架宽度。 默认为报告的默认元素宽度。

height (int) – 以 CSS 像素为单位的框架高度。 默认为 150。

scrolling (bool) – 如果为 True，则在内容大于 iframe 时显示滚动条。 否则，不显示滚动条。 默认为假。
例子：

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
import streamlit as st
import streamlit.components.v1 as components

# bootstrap 4 collapse example

   html_data= """
    <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/4.0.0/css/bootstrap.min.css" integrity="sha384-Gn5384xqQ1aoWXA+058RXPxPg6fy4IWvTNh0E263XmFcJlSAwiGgFAW/dAiS6JXm" crossorigin="anonymous">
    <script src="https://code.jquery.com/jquery-3.2.1.slim.min.js" integrity="sha384-KJ3o2DKtIkvYIK3UENzmM7KCkRr/rE9/Qpg6aAZGJwFDMVNA/GpGFF93hXpG5KkN" crossorigin="anonymous"></script>
    <script src="https://maxcdn.bootstrapcdn.com/bootstrap/4.0.0/js/bootstrap.min.js" integrity="sha384-JZR6Spejh4U02d8jOt6vLEHfe/JQGiRRSQQxSfFWpi1MquVdAyjUar5+76PVCmYl" crossorigin="anonymous"></script>
    <div id="accordion">
      <div class="card">
        <div class="card-header" id="headingOne">
          <h5 class="mb-0">
            <button class="btn btn-link" data-toggle="collapse" data-target="#collapseOne" aria-expanded="true" aria-controls="collapseOne">
            Collapsible Group Item #1
            </button>
          </h5>
        </div>
        <div id="collapseOne" class="collapse show" aria-labelledby="headingOne" data-parent="#accordion">
          <div class="card-body">
            Collapsible Group Item #1 content
          </div>
        </div>
      </div>
      <div class="card">
        <div class="card-header" id="headingTwo">
          <h5 class="mb-0">
            <button class="btn btn-link collapsed" data-toggle="collapse" data-target="#collapseTwo" aria-expanded="false" aria-controls="collapseTwo">
            Collapsible Group Item #2
            </button>
          </h5>
        </div>
        <div id="collapseTwo" class="collapse" aria-labelledby="headingTwo" data-parent="#accordion">
          <div class="card-body">
            Collapsible Group Item #2 content
          </div>
        </div>
      </div>
    </div>
    """
    components.html(html_data, width=None, height=300,scrolling=False)
)

  1. 呈现 iframe URL用用：

    1
    streamlit.components.v1.iframe(src, width=None, height=None, scrolling=False)

    参数
    src (str) – 要嵌入的页面的 URL。

width (int) – 以 CSS 像素为单位的框架宽度。 默认为报告的默认元素宽度。

height (int) – 以 CSS 像素为单位的框架高度。 默认为 150。

scrolling (bool) – 如果为 True，则在内容大于 iframe 时显示滚动条。 否则，不显示滚动条。 默认为假。
例子：

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
import streamlit as st
import pandas as pd
import numpy as np
import streamlit.components.v1 as components

st.set_page_config( page_title="Streamlit 练习 ",   layout="wide" )

page_html_luckysheet = """ 
   <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/4.0.0/css/bootstrap.min.css" integrity="sha384-Gn5384xqQ1aoWXA+058RXPxPg6fy4IWvTNh0E263XmFcJlSAwiGgFAW/dAiS6JXm" crossorigin="anonymous">
    <script src="https://code.jquery.com/jquery-3.2.1.slim.min.js" integrity="sha384-KJ3o2DKtIkvYIK3UENzmM7KCkRr/rE9/Qpg6aAZGJwFDMVNA/GpGFF93hXpG5KkN" crossorigin="anonymous"></script>
    <script src="https://maxcdn.bootstrapcdn.com/bootstrap/4.0.0/js/bootstrap.min.js" integrity="sha384-JZR6Spejh4U02d8jOt6vLEHfe/JQGiRRSQQxSfFWpi1MquVdAyjUar5+76PVCmYl" crossorigin="anonymous"></script>
    <div id="accordion">
      <div class="card">
        <div class="card-header" id="headingOne">
          <h5 class="mb-0">
            <button class="btn btn-link" data-toggle="collapse" data-target="#collapseOne" aria-expanded="true" aria-controls="collapseOne">
            Collapsible Group Item #1
            </button>
          </h5>
        </div>
        <div id="collapseOne" class="collapse show" aria-labelledby="headingOne" data-parent="#accordion">
          <div class="card-body">
            Collapsible Group Item #1 content
          </div>
        </div>
      </div>
      <div class="card">
        <div class="card-header" id="headingTwo">
          <h5 class="mb-0">
            <button class="btn btn-link collapsed" data-toggle="collapse" data-target="#collapseTwo" aria-expanded="false" aria-controls="collapseTwo">
            Collapsible Group Item #2
            </button>
          </h5>
        </div>
        <div id="collapseTwo" class="collapse" aria-labelledby="headingTwo" data-parent="#accordion">
          <div class="card-body">
            Collapsible Group Item #2 content
          </div>
        </div>
      </div>
    </div>
"""
# st.markdown( page_html_head, unsafe_allow_html=True)
container_top = st.container()
container_body = st.container()

# Top
with container_top:
    st.markdown(" [新浪网](https://www.sina.com.cn) /[我的笔记](https://superigbt_superigbt.gitee.io) ")
    st.image("/home/frankli/temp/建站/banner/mybanner4-1.jpg",caption='my banner', use_column_width=True)


# Body
with container_body:
    # components.iframe( "https://superigbt_superigbt.gitee.io/")
    left_side, right_side = st.columns([1,6])
    # 左边，注意with语句的下一行缩进
    with left_side: 
                    left_side.subheader(" 左边的窄列，预留菜单树 ")
    # 右边,注意缩进。
    with right_side: 
                    components.html( page_html_luckysheet )
                    components.iframe("https://superigbt_superigbt.gitee.io",width=None, height=600, scrolling=True)
python学习

panda笔记1

一. Python 将数据框 DataFrame转为html表格,DataFrame.to_html()详解
1
2
3
4
DataFrame.to_html(buf=None, columns=None, col_space=None, header=True, index=True,na_rep='NaN', formatters=None,
				  float_format=None, sparsify=None, index_names=True,justify=None, bold_rows=True,classes=None,
				  escape=True, max_rows=None, max_cols=None,show_dimensions=False, notebook=False, decimal='.',
				  border=None)
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
buf : StringIO-like, 可选
    写入缓冲区。
columns : sequence，可选
    要转化的列的列名；默认值 None 为所有列转化。
col_space : int，可选
    每列的最小宽度。
header : bool，可选
    是否打印列标签，默认为 True。
index : 布尔值，可选
    是否打印索引（行）标签，默认为 True。
na_rep : 字符串，可选
    指定 NAN 的字符串表示形式，默认为 'NaN'。
formatters : 多个单参数函数组成的列表或字典，可选
    格式化程序可按列表的所索引或字典的键名称应用于列元素，默认为 None。
    每个单参数函数的结果必须是一个 unicode 字符串。列表的长度必须等于列数。
float_format: 单参数函数，可选
    用于将列元素设置为浮点数的格式化程序功能，默认为无。
    此单参数函数的结果必须是 unicode 字符串。
sparsify : bool，可选
    默认为 True。输入 False 时，对于具有层次结构索引的 DataFrame，会在每一行打印多重索引。
index_names : bool，可选
    打印索引名称，默认为 True。
line_width : int，可选
    换行符的宽度，默认为不换行。
justify : 列标签对齐方式, 可选
    左右对齐列标签。默认为 None时，使用打印配置中的选项（由 set_option 控制），则右对齐。
bold_rows : bool, 可选
    对横向表格线进行加粗。
classes : CSS类(es)适用于生成的html表, 可选
    默认 None
escape : bool, 可选
    将 "<", ">", "&" 转化成 html 安全序列（？？），默认 True。
max_rows : int, 可选
    显示最大行数。
max_cols : int, 可选
    显示最大列数。
decimal : str, 可选
    小数分隔符, 默认为 '.'。
border : int， 可选
    表格外边框宽度，默认为 1，参数为 0 时表格无边框。数值越大外边框越宽。
二. pd.read_excel方法说明
1
2
3
4
5
6
pd.read_excel(io, sheet_name=0, header=0, names=None,      index_col=None, 
       usecols=None, squeeze=False,dtype=None, engine=None, 
       converters=None, true_values=None, false_values=None, 
       skiprows=None, nrows=None, na_values=None, parse_dates=False, 
       date_parser=None, thousands=None, comment=None, skipfooter=0, 
       convert_float=True, **kwds)
1
2
3
4
5
6
io：excel文件
sheet_name：返回指定sheet，默认索引0返回第一个，也可用名称，如果返回多个则可用列表，为None则返回全表
header：指定表头，也可用列表指定多行
names：自定义列名，长度和Excel列长度必须一致
index_col：用作索引的列
usecols：读取指定的列，参数为列表，如[0,1]表示第1和第2列
三. 使用to_excel()函数将DataFrame导出到excel文件
1
2
3
DataFrame.to_excel(excel_writer, sheet_name='Sheet1', na_rep='', float_format=None, columns=None,
        header=True, index=True, index_label=None, startrow=0, startcol=0, engine=None, merge_cells=True,
        encoding=None, inf_rep='inf', verbose=True, freeze_panes=None)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
excel_writer：文件路径或现有的ExcelWriter。
sheet_name：它是指包含DataFrame的工作表的名称。
na_rep：指定要写入的表如果有空值（NAN）,则需要填入的字符串。
float_format：这是一个可选参数, 用于格式化浮点数字符串。
columns：指定哪些列要写入新表。
header：是否把列名也写入excel表，默认为True，即写入
index：是否把索引也写入excel表，默认为True，即写入。
index_label：引用索引列的列标签。如果未指定, 并且标头和索引为True, 则使用索引名称。如果DataFrame使用MultiIndex, 则应给出一个序列。
startrow：默认值0。它指向转储DataFrame的左上单元格行。
startcol：默认值0。它指向转储DataFrame的左上方单元格列。
engine：这是一个可选参数, 用于写入要使用的引擎, openpyxl或xlsxwriter。
merge_cells：返回布尔值, 其默认值为True。它将MultiIndex和Hierarchical行写为合并的单元格。
encoding：这是一个可选参数, 可对生成的excel文件进​​行编码。仅对于xlwt是必需的。
inf_rep：它也是一个可选参数, 默认值为inf。它通常表示无穷大。
verbose：返回一个布尔值。它的默认值为True。
它用于在错误日志中显示更多信息。
Frozen_panes：它也是一个可选参数, 用于指定要冻结的最底部一行和最右边一列。