flask文件名文件上传

A. 新浪云怎么部署 python flask

首先安装python，这个我就不多说了，记得配置好系统的环境变量，python和python包（Scripts目录）都要加入系统的环境变量。
接下来就pip安装flask，windows下的命令为：
$ pip install flask
接下来创建一个文件夹，就是你将来整个工程的文件。通过cmd命令进入到这个文件夹中。（cd命令）
然后在这个文件夹中创建一个python文件，py为后缀的文件。

接下来编辑这个文件（文本编辑器、IDE都可以）
from flask import Flask
app = Flask(__name__)
@app.route('/')
def index():
return '
Hello World!
'
if __name__ == '__main__':
app.run(debug = True)
写入代码就可以简单的启动服务器了，默认根目录下返回“hello，world！”，如何运行的就只需要在cmd中运行
$ python myapp.py
运行成功的话可以看到下图的提示。
访问localhost:5000的时候（默认端口5000，可以通过host参数修改），例如
app.run(debug=True,host='0.0.0.0:5000')
基本上这样完成了flask的基本配置，接下来就是将其放到新浪云SAE上，SAE本身就支持flask框架的部署，但是后期我们需要引入其他的一些第三方的包，因此最好就是讲自己的包放到工程文件中调用。
方法就是在使用pip安装的时候，使用这样子的命令：
$ pip install -t vendor PACKAGENAME
这个样子在本地安装的时候就会将包放在一个vendor文件夹中，然后安装SAE官方的文档，在工程文件中添加一个名为“index.wsgi”的文件，内容为：
import sae
sae.add_vendor_dir('vendor')
from myapp import app
application = sae.create_wsgi_app(app)
这样子基本就完成了，只需要讲文件上传到SAE上就可以完成部署。
SAE上的操作记得在新建应用的时候选择python2.7，然后我用的代码管理方式是git。
接下来的方式就是git的内容了，这里我就不多说，写下几个命令：
将仓库的内容复制到本地
$git clone 你的git仓库地址
创建分支
$git branck 分支名
使用分支
$git checkout 分支名
修改代码
$git add --all
$git commit -a "注释"
$git pust 分支名
（以前都是用svn的所以git还不是特别熟）
部署上传完代码之后就可以好好折腾啦

B. 用flask做了个文件管理,上传速度太慢了

你应该只是通过SAE验证了WEIXIN 的开发接口，如果你代码部署成功了，应该不会问这问题！目测你想表达的是，在SAE验证握手，POST数据从自己服务器返回！不过这太反人类了，排除。 只剩下一种可能，你只是验证了下，业务逻辑还没有，建议你先把业...

C. flask怎么获取上传文件的大小和其他信息

上传文件的时候也是可以获取的(这个坑填了好久)

upload_file = request.files["upload_file"]
size = len(upload_file.read())

这样就能获取文件的大小了，单位是字节
flask官方文档也提供了一个函数content_length,但是获取的结果都是0，所以没用。
有兴趣可以参考filestorage的文档自己测下

D. Flask表单疑问，这个name是怎么传进来的

没看form有关的源码，但是应该是这样的∶

首先，你得理解像flask这种MVC（或者说MTC）的基本运行机制。
- 对于flask的view，你得知道wsgi协议（如果不清楚，请自行Google之）。

更底层（逻辑上的底层）的HTTP utils（flask用的是werkzeug）将client端的HTTP requests等进行parse，并且将其构建为wsgi的environment（包含了request及其他信息）。

wsgi
server在process请求的过程是：根据wsgi协议构建environ，将其传入flask app
instance（这个即为flask框架实现的wsgi app），flask app
instance用这个environ和自己的``start_response``
method（这个也是uwsgi协议规约）完成请求处理并response。

flask有一个线程级（或greenlet）的request对象。在真正process response之前，将environ丢到这个request对象里，之后这个request跟着你的那个线程就成为了默契的炮友~~直至response完成或线程完蛋。

views里面的那一坨坨的route的作用是啥捏？这个就是url routing了，就是我在你的站点上点了一个特定的url，flask要如何满足你。你得说出你想要的东西吧。

那么views是什么时候用到呢？废话，当然还是在接收并理解请求之后到响应之前。

好
了，flask app instance在处理你的需求的时候从request对象里拿到了你请求的url，这个就相当于一把key，然后app
instance根据这个key去views里找到了对应的锁（你想要的处理逻辑，就是views里的route下面的function），这个锁啊，她
一旦被打开了，满足你需求的时刻也就快了 ~ ~
P.S. 至于如何匹配到这个锁的呢，这个就是url mapping了，就是一堆正则匹配（别小看这个，如果你用过flask的blueprint，你会明白写这么个mapping也是件爽hi了的事情咯）

- model & controller呢？
你的需求其实就是要flask给你response，response其实呢就是数据（不管是RESTFUL API还是template形式，都是你撸出的data）。

数据这坨翔实怎么来的呢？就是你从数据库（广义，包括sql & nosql db，内存级缓存，磁盘文件等等等等）拿到的，至于data的来源嘛，可能是你自己插的，或者是从别的地方哭着要来的。

model
就是干这活的，只不过它比较抽象，将数据库操作转成了对Python对象的操作（这个就是大名鼎鼎的ORM，其实并没有什么卵用，ORM写多了你连查询优
化都忘了，如果你有比较高的performance需求也有很多时间，就自己撸高效检索方案吧，我没少被这玩意儿坑%>_<%）。

controller这玩意儿你其实可以不要，不过为了做逻辑分离，让你撸业务撸的漂亮点儿还是用它吧。

OK，说了这么多，不知道有没有人能看懂，如果没看懂，让我思考会儿吧 ~ ~

========================================================================
简而言之呢，你用flask作application的时候，MVC各司其职堆好你产生data的逻辑即可，其它你一概不用管。

靠，终于可以回到你的问题上了：

先看下Form这玩意儿：
from flask.ext.wtf import Form
from wtforms import StringField, SubmitField
from wtforms.validators import Required

class NameForm(Form):
name = StringField('What is your name?', validators=[Required()])
submit = SubmitField('Submit')

这就是一个类而已，和model里面的那些玩意儿没本质区别，也都是一个映射关系。model是将数据库啥的和Python对象映射；Form是将HTML表单（form）和这个从flask.ext.wtf.Form及其子类映射。

再来看看这玩意儿：
1 @app.route('/', methods=['GET', 'POST'])
2 def index():
3 name = None
4 form = NameForm()
5 if form.validate_on_submit():
6 name = form.name.data
7 form.name.data = ''
8 return render_template('index.html', form=form, name=name)

首先来分析一下执行过程：
哎呀，这个只是个route嘛，它哪有执行过程。
执行是由app instance做的嘛，好吧，其实它是被app instance做的。

在
展开之前看一下route后面那个 methods=['GET',
'POST']。这玩意的意思是说，当我遇到有与``index``（即上面route下面的那个index）匹配的的请求时，我可以用GET或者
POST方法，其他的像PUT、DELETE等HTTP verb我不让你丫玩儿。

当你把你的这个flask应用deploy到web server或者在本地run test server的时候，你在浏览器里输入 http://xxxxxx.ooooo.xxoo/index 的时候，你向server发射的是``GET``炮弹，flask instance接受了你的弹，然后route到了index这个函数，好吧，激动人心的时刻到了：

#3. name = None 这个就是个赋值
#4. form = NameForm() 好吧，这个就是NameForm类的实例化，拿到一个form object。
#5.
if form.validate_on_submit(): 呵呵，这个嘛，意思是问一下#2中实例化的form
object，SB，你是在被人(1)submit（提交）并且(2)提交满足我的要求么？
好吧，前面说过了，我是在GET，而没有在submit（submit在HTML中为POST），好吧，我连(1)都不满足，所以也就没有#6、#7什么
事儿了。
#8 好的，app instance终于快要向你回馈了。给我把前面的from object和name变量一起带到index.html这个文件里吧。
哈哈，终于有jinja2的活儿了，@题主， 你丫也把index.html发上来呀 = =
index.html
里你写了个表单，里面有个叫做``name``的field和一个``submit``按钮，这些field和你的``NameForm``对应，好了，
对应填充的活儿和就交给jinja2吧，它会给你一个最终将在用户浏览器显示的index.html。

view的使命完成了，它成功的生成了数据。

app instance 拿到了view的数据，也该向client端发最终响应了。OK，server完成了这次request的response，用户拿到最终想要的东西了。

浏览器或者UA干的活儿我就不展开了，我的手已经抽筋了，

现在在用户的浏览器上，看到了index.html，上面有一个表单，那个表单上面有个文本框（有``What is your name?``的placeholder）和一个Submit提交按钮。

好
了，用户在那个文本框中写了一个名字，比如``John``，然后按了那个``Submit``按钮，这次提交回向server发射一个``POST``
请求，这个请求里面会带上文本框的名字（哈哈，就是name）和文本框name里面的值（yeah，就是``John``）。然后呢，到flask
instance中，request对象（如果不知道这是什么东西，看前文）里就会有所有这些有关请求的数据了。

辣么，辣么这跟from有毛线关系呢？？？？

其实吧，form中的数据是flask从request（request是从environ构建的）中拿到并映射进form属性中的（映射过程发生在你实例化form的时候），这个过程我也不展开了。好吧，不知道有没有解释你
name = form.name.data

为什么会有数据的疑问。

好
吧，总结起来就是，HTTP utils将用户的raw request解析成符合wsgi规范的environ，然后flask
instance将environ丢到线程级的request
object里，在你实例化flask.ext.wtf.Form及其子类时，会从request object里解析并映射数据到form中。

关于读书的话，如果你觉得你实在看不明白，那可能是有关web底层一点的知识稍微欠缺，可以补补这块的知识，对于框架的处理机制，最好的办法是 看！！！源！！！！码！！！！！

看不懂就补基础，如此而已。

上面过程都是我信手打出来的，也好久没用flask了，写的时候也没查资料，如有bug或建议可以告诉我，以便我修改。

最后希望能帮到你/你们。

E. 如何用 flask 优雅的实现 restful api

首先，安装Flask
pip install flask
阅读这篇文章之前我假设你已经了解RESTful API的相关概念，如果不清楚，可以阅读我之前写的这篇博客[Designing a RESTful Web API
Flask是一个使用Python开发的基于Werkzeug的Web框架。
Flask非常适合于开发RESTful API，因为它具有以下特点：
?使用Python进行开发，Python简洁易懂
?容易上手
?灵活
?可以部署到不同的环境
?支持RESTful请求分发
我一般是用curl命令进行测试，除此之外，还可以使用Chrome浏览器的postman扩展。
资源
首先，我创建一个完整的应用，支持响应/, /articles以及/article/:id。
from flask import Flask, url_for
app = Flask(__name__)
@app.route('/')
def api_root():
return 'Welcome'
@app.route('/articles')
def api_articles():
return 'List of ' + url_for('api_articles')
@app.route('/articles/<articleid>')
def api_article(articleid):
return 'You are reading ' + articleid
if __name__ == '__main__':
app.run()
可以使用curl命令发送请求：
响应结果分别如下所示：
GET /
Welcome
GET /articles
List of /articles
GET /articles/123
You are reading 123
路由中还可以使用类型定义:
@app.route('/articles/<articleid>')
上面的路由可以替换成下面的例子：
@app.route('/articles/<int:articleid>')
@app.route('/articles/<float:articleid>')
@app.route('/articles/<path:articleid>')
默认的类型为字符串。
请求
请求参数
假设需要响应一个/hello请求，使用get方法，并传递参数name
from flask import request
@app.route('/hello')
def api_hello():
if 'name' in request.args:
return 'Hello ' + request.args['name']
else:
return 'Hello John Doe'
服务器会返回如下响应信息：
GET /hello
Hello John Doe
GET /hello?name=Luis
Hello Luis
请求方法
Flask支持不同的请求方法：
@app.route('/echo', methods = ['GET', 'POST', 'PATCH', 'PUT', 'DELETE'])
def api_echo():
if request.method == 'GET':
return "ECHO: GET\n"
elif request.method == 'POST':
return "ECHO: POST\n"
elif request.method == 'PATCH':
return "ECHO: PACTH\n"
elif request.method == 'PUT':
return "ECHO: PUT\n"
elif request.method == 'DELETE':
return "ECHO: DELETE"
可以使用如下命令进行测试:
curl -X PATCH :5000/echo
不同请求方法的响应如下：
GET /echo
ECHO: GET
POST /ECHO
ECHO: POST
...
请求数据和请求头
通常使用POST方法和PATCH方法的时候，都会发送附加的数据，这些数据的格式可能如下：普通文本(plain text)， JSON，XML，二进制文件或者用户自定义格式。
Flask中使用request.headers类字典对象来获取请求头信息，使用request.data 获取请求数据，如果发送类型是application/json，则可以使用request.get_json()来获取JSON数据。
from flask import json
@app.route('/messages', methods = ['POST'])
def api_message():
if request.headers['Content-Type'] == 'text/plain':
return "Text Message: " + request.data
elif request.headers['Content-Type'] == 'application/json':
return "JSON Message: " + json.mps(request.json)
elif request.headers['Content-Type'] == 'application/octet-stream':
f = open('./binary', 'wb')
f.write(request.data)
f.close()
return "Binary message written!"
else:
return "415 Unsupported Media Type ;)"
使用如下命令指定请求数据类型进行测试：
curl -H "Content-type: application/json" \
-X POST :5000/messages -d '{"message":"Hello Data"}'
使用下面的curl命令来发送一个文件:
curl -H "Content-type: application/octet-stream" \
-X POST :5000/messages --data-binary @message.bin
不同数据类型的响应结果如下所示：
POST /messages {"message": "Hello Data"}
Content-type: application/json
JSON Message: {"message": "Hello Data"}
POST /message <message.bin>
Content-type: application/octet-stream
Binary message written!
注意Flask可以通过request.files获取上传的文件，curl可以使用-F选项模拟上传文件的过程。
响应
Flask使用Response类处理响应。
from flask import Response
@app.route('/hello', methods = ['GET'])
def api_hello():
data = {
'hello' : 'world',
'number' : 3
}
js = json.mps(data)
resp = Response(js, status=200, mimetype='application/json')
resp.headers['Link'] = 'http://luisrei.com'
return resp
使用-i选项可以获取响应信息：
curl -i :5000/hello
返回的响应信息如下所示：
GET /hello
HTTP/1.0 200 OK
Content-Type: application/json
Content-Length: 31
Link: http://luisrei.com
Server: Werkzeug/0.8.2 Python/2.7.1
Date: Wed, 25 Apr 2012 16:40:27 GMT
{"hello": "world", "number": 3}
mimetype指定了响应数据的类型。
上面的过程可以使用Flask提供的一个简便方法实现：
from flask import jsonify
...
# 将下面的代码替换成
resp = Response(js, status=200, mimetype='application/json')
# 这里的代码
resp = jsonify(data)
resp.status_code = 200
状态码和错误处理
如果成功响应的话，状态码为200。对于404错误我们可以这样处理：
@app.errorhandler(404)
def not_found(error=None):
message = {
'status': 404,
'message': 'Not Found: ' + request.url,
}
resp = jsonify(message)
resp.status_code = 404
return resp
@app.route('/users/<userid>', methods = ['GET'])
def api_users(userid):
users = {'1':'john', '2':'steve', '3':'bill'}
if userid in users:
return jsonify({userid:users[userid]})
else:
return not_found()
测试上面的两个URL，结果如下：
GET /users/2
HTTP/1.0 200 OK
{
"2": "steve"
}
GET /users/4
HTTP/1.0 404 NOT FOUND
{
"status": 404,
"message": "Not Found: :5000/users/4"
}
默认的Flask错误处理可以使用@error_handler修饰器进行覆盖或者使用下面的方法：
app.error_handler_spec[None][404] = not_found
即使API不需要自定义错误信息，最好还是像上面这样做，因为Flask默认返回的错误信息是HTML格式的。
认证
使用下面的代码可以处理 HTTP Basic Authentication。
from functools import wraps
def check_auth(username, password):
return username == 'admin' and password == 'secret'
def authenticate():
message = {'message': "Authenticate."}
resp = jsonify(message)
resp.status_code = 401
resp.headers['WWW-Authenticate'] = 'Basic realm="Example"'
return resp
def requires_auth(f):
@wraps(f)
def decorated(*args, **kwargs):
auth = request.authorization
if not auth:
return authenticate()
elif not check_auth(auth.username, auth.password):
return authenticate()
return f(*args, **kwargs)
return decorated
接下来只需要给路由增加@require_auth修饰器就可以在请求之前进行认证了：
@app.route('/secrets')
@requires_auth
def api_hello():
return "Shhh this is top secret spy stuff!"
现在，如果没有通过认证的话，响应如下所示：
GET /secrets
HTTP/1.0 401 UNAUTHORIZED
WWW-Authenticate: Basic realm="Example"
{
"message": "Authenticate."
}
curl通过-u选项来指定HTTP basic authentication，使用-v选项打印请求头：
curl -v -u "admin:secret"
响应结果如下：
GET /secrets Authorization: Basic YWRtaW46c2VjcmV0
Shhh this is top secret spy stuff!
Flask使用MultiDict来存储头部信息，为了给客户端展示不同的认证机制，可以给header添加更多的WWW-Autheticate。
resp.headers['WWW-Authenticate'] = 'Basic realm="Example"'resp.headers.add('WWW-Authenticate', 'Bearer realm="Example"')
调试与日志
通过设置debug=True来开启调试信息：
app.run(debug=True)
使用Python的logging模块可以设置日志信息：
import logging
file_handlewww.huashijixun.com?.ogging.FileHandler('app.log')
app.logger.addHandler(file_handler)
app.logger.setLevel(logging.INFO)
@app.route('/hello', methods = ['GET'])
def api_hello():
app.logger.info('informing')
app.logger.warning('warning')
app.logger.error('screaming bloody murder!')
return "check your logs\n"
CURL 命令参考
选项
作用
-X 指定HTTP请求方法，如POST，GET
-H 指定请求头，例如Content-type:application/json
-d 指定请求数据
--data-binary 指定发送的文件
-i 显示响应头部信息
-u 指定认证用户名与密码
-v 输出请求头部信息

F. python flask 上传多个文件，代码怎么写

include <iostream>
#include <stdio.h>
int jc(int m){
if(m!=1) return m*jc(m-1);
else return 1;
}
int c(int m,int n){
if(m>=n) return jc(m)/(jc(n)*jc(m-n));
}
int main(void){
int m,n;
scanf("%d%d",&m,&n);
printf("%d\n",c(m,n));
return 0;
}

G. 如何把css，js文件发布到服务器上flask

flask的静态文件是位于应用的 /static 中的

你可以直接在html模板中引用该路径，如下：

<link href="/static/css/demo.css" rel="stylesheet" type="text/css" />

url_for 构造路径

当然，也可使用 url_for 构造，代码如 url_for("static",filename="css/demo.css")

更改上述代码及模板文件，再次运行并查看

H. flask是什么意思

Flask也被称为 “microframework” ，因为它使用简单的核心，用 extension 增加其他功能。Flask没有默认使用的数据库、窗体验证工具。然而，Flask保留了扩增的弹性，可以用Flask-extension加入这些功能：ORM、窗体验证工具、文件上传、各种开放式身份验证技术。

I. python+flask上传文件ioerror errno21 is a directory怎么解决

0down voteaccepted

Second parameter of urlretrieve should be a path to a file not to a directory.
urllib.urlretrieve(url[, filename[, reporthook[, data]]])
Copy a network object denoted by a URL to a local file, if necessary.
You may fix it like:
urllib.urlretrieve(text_in_clipboard, "/home/thomasshera/Pictures/Star Wars/download.temp")

J. python中flask框架 怎么选择文件

Flask是一个使用Python编写的轻量级Web应用框架，凭借更灵活、轻便、安全且容易上手的特性，成为企业常用的Python框架之一。在完成Web前端、Linux以及MySQL相关的课程之后，专业的杭州Python学习班都会讲解Flask框架知识，以下是整理的相关知识点。

Flask是一个基于Python开发并且依赖jinja2模板和Werkzeug WSGI服务的一个微型框架，对于Werkzeug本质是Socket服务端，其用于接收http请求并对请求进行预处理，然后触发Flask框架。开发人员基于Flask框架提供的功能对请求进行相应的处理，并返回给用户，如果要返回给用户复杂的内容时，需要借助jinja2模板来实现对模板的处理，即：将模板和数据进行渲染，将渲染后的字符串返回给用户浏览器。

默认情况下，Flask不包含数据库抽象层、表单验证，或是其它任何已有多种库可以胜任的功能。然而，Flask支持用扩展来给应用添加这些功能，如同是Flask本身实现的一样。众多的扩展提供了数据库集成、表单验证、上传处理、各种各样的开放认证技术等功能。

Flask框架的特点：
1）Flask自由、灵活，可扩展性强，第三方库的选择面广，开发时可以结合自己最喜欢用的轮子，也能结合最流行最强大的Python库；
2）入门简单，即便没有多少web开发经验，也能很快做出网站；
3）非常适用于小型网站；
4）非常适用于开发Web服务的API；
5）开发大型网站无压力，但代码架构需要自己设计，开发成本取决于开发者的能力和经验。

Flask框架运行解释
1.app = Flask(__name__)
创建Flask对象app，Flask类的构造函数只有一个必须指定的参数，即程序主模块或包的名字。在大多数程序中，Python的__name__变量就是所需要的值。

[email protected]('/')
web浏览器把请求发送给Web服务器,Web服务器再把请求发送给Flask程序实例。程序实例需要知道对每个URL请求运行哪些代码，所以保存了一个URL到Python函数的映射关系。处理URL和函数之间的关系的程序称为路由。在Flask程序中定义路由的最简便方式，是使用程序实例提供的app.route修饰器，把修饰的函数注册为路由。route()装饰器告诉 Flask什么样的URL 能触发我们的函数。这和Java中的注释有异曲同工之妙。修饰器是Python语言的标准特性，可以使用不同的方式修改函数的行为。惯常用法是使用修饰器把函数注册为事件的处理程序。

3.def index():函数
index()函数放在@app.route('/')后面，所以就是把index()函数注册为路由。如果部署程序的服务器域名为http://127.0.0.1:5000/,在浏览器中访问http://127.0.0.1:5000/后，会触发服务器执行index()函数。

[email protected]('/user/')
同@app.route('/')，如果部署程序的服务器域名为http://127.0.0.1:5000/，在浏览器中访问http://127.0.0.1:5000/后，会触发服务器执行下方修饰函数。

5.app.run(debug=True)
程序实例用run方法启动Flask继承Web服务器。

6.if __name__ == '__main__'
当Python解释器，读py文件,它会执行它发现的所有代码。在执行代码之前，它会定义一些变量。例如，如果这个py文件就是主程序，它会设置__name__变量为"__main__"。如果这个py被引入到别的模块，__name__会被设置为该模块的名字。