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__會被設置為該模塊的名字。