flask as web Foundation

#Reference
https://www.jianshu.com/p/6452596c4edb

#Chinese Manual http://docs.jinkan.org/docs/flask/quickstart.html http://docs.jinkan.org/docs/flask/index.html

w3cschool: https://www.w3cschool.cn/flask/

flask is a web micro framework of python demo / or simple web tool is very convenient

install flask:pip install flask

Do you need a well configured directory structure to make a formal website

flask-demo/
  ├ run.py           # Application launcher
  ├ config.py        # Environment configuration
  ├ requirements.txt # List all Python packages the application depends on
  ├ tests/           # Test code package
  │   ├ __init__.py 
  │   └ test_*.py    # test case
  └ myapp/
	  ├ admin/       # Blueprint catalog
	  ├ static/
	  │   ├ css/     # css file directory
	  │   ├ img/     # Picture file directory
	  │   └ js/      # js file directory
	  ├ templates/   # Template file directory
	  ├ __init__.py    
	  ├ forms.py     # Store all forms and, if more, turn them into one package
	  ├ models.py    # Store all data models, and if there are many, turn them into one package
	  └ views.py     # Store all view functions. If there are many, change them into one package

Simplest test: test.py

python test.py After, the browser enters localhost:5000 You can see the web page showing Hello world. Or enter: 127.0.0.1:5000

from flask import Flask
app = Flask(__name__)
@app.route('/')
def index():
	return 'Hello World'
if __name__ == '__main__':
	app.debug = True # Set debug mode, and turn off debug in production mode
	app.run()

Jinja2 is a widely used template engine, which can easily embed data into web price inquiry

from  flask import  Flask
from  flask import  render_template
app  =  Flask(__name__)
@app.route('/hello')
@app.route('/hello/<name>')
def  hello(name=None):
	#Rendering hello.html Template, pass name data in
	return  render_template('hello.html',  name=name)
if  __name__  ==  '__main__':
	app.run(host='0.0.0.0',  debug=True)

#Template file: hello.html " http://localhost:5000/hello/world"

<!doctype html>
<title>Hello Sample</title>
{% if name %}
  <h1>Hello {{ name }}!</h1>
{% else %}
  <h1>Hello World!</h1>
{%  endif  %}

#Template inheritance# father.html

<!doctype html>
<title>Hello Sample</title>
<link rel="stylesheet"  type="text/css"  href="{{ url_for('static', filename='style.css') }}">
<div class="page">
	{% block body %}
	{% endblock %}
</div>

#Inherit the above template

{%  extends  "father.html"  %}
{%  block  body  %}
{%  if  name  %}
  <h1>Hello {{ name }}!</h1>
{% else %}
  <h1>Hello World!</h1>
{%  endif  %}
{%  endblock  %}

session records the logged in information to avoid repeatedly entering the login page

from flask import Flask,url_for,request,render_template,redirect,session
@app.route('/login', methods=['POST', 'GET'])
def login():
	if request.method == 'POST':
		if request.form['user'] == 'admin':
			session['user'] = request.form['user']
			return 'Admin login successfully!'
		else:
			return 'No such user!'
	if 'user' in session:
		return 'Hello %s!' % session['user']
	else:
		title = request.args.get('title', 'Default')
		return render_template('login.html', title=title)
@app.route('/logout')
def logout():
	session.pop('user', None)
	return redirect(url_for('login'))
app.secret_key = '123456'
if __name__ == "__main__":
	app.run(debug=True)

Use cookies

from flask import Flask,url_for,request,render_template,redirect,session,make_response
import time
@app.route('/login', methods=['POST', 'GET'])
def login():
	response = None
	if request.method == 'POST':
		if request.form['user'] == 'admin':
			session['user'] = request.form['user']
			response = make_response('Admin login successfully!')
			#Set Cookie, save in browser, the third parameter max_age sets the validity period (seconds). If it is not set, the browser will be invalid after closing
			response.set_cookie('login_time', time.strftime('%Y-%m-%d %H:%M:%S'))
		...
	else:
		if 'user' in session:
			#" request.cookies ”Object is a dictionary that holds the Cookie of the browser. Use its "get()" function to get the corresponding key value.
			login_time = request.cookies.get('login_time')
			response = make_response('Hello %s, you logged in on %s' % (session['user'], login_time))
		...
	return response
app.secret_key = '123456' #Set secret key, preferably random
if __name__ == "__main__":
	app.run(debug=True)

error handling

from flask import Flask,abort
app = Flask(__name__)
@app.route('/error')
def error():
	abort(404) #immediate withdrawal
@app.errorhandler(404)
def page_not_found(error):
	return render_template('404.html'), 404 #Return to rewritten error page
if __name__ == "__main__":
	app.run(debug=True)

URL redirection:

#Without /, Flask will automatically redirect to the correct address.

@app.route('/projects/')
def projects():
	return 'The project page'
#Flag will directly report 404 NOT FOUND error after / after the end
@app.route('/about')
def about():
	return 'The about page'
---------------------------------------------
from flask import session, redirect
@app.route('/')
def index():
	if 'user' in session:
		return 'Hello %s!' % session['user']
	else:
		#The redirect() "function directs a client to another web address when browsing it
		#The second parameter of "redirect()" is the HTTP status code. The available values are 301, 302, 303, 305 and 307. The default value is 302
		return redirect(url_for('login'), 302)

#Upload file #werkzeug determines whether the file name is safe pip install werkzeug #Server:

from flask import Flask, request  
from werkzeug.utils import secure_filename  
import os

app = Flask(__name__)  
#Configuration information upload directory 
app.config['UPLOAD_FOLDER'] = 'static/uploads/'
#Control the size of uploaded files
app.config['MAX_CONTENT_LENGTH'] = 16 * 1024 * 1024 #16MB
#Upload file format, suffix
app.config['ALLOWED_EXTENSIONS'] = set(['png', 'jpg', 'jpeg', 'gif'])

# For a given file, return whether it's an allowed type or not
def allowed_file(filename):  
	return '.' in filename and 
		   filename.rsplit('.', 1)[1] in app.config['ALLOWED_EXTENSIONS']

@app.route('/')
def hello_world():  
	return 'hello world'

@app.route('/upload', methods=['POST'])
def upload():  
	upload_file = request.files['image01']#Image is marked with "image01"
	file_content = request.files['image01'].stream.read()#Get the content of the uploaded file
	if upload_file and allowed_file(upload_file.filename):
		filename = secure_filename(upload_file.filename)
		#route
		upload_file.save(os.path.join(app.root_path, app.config['UPLOAD_FOLDER'], filename))
		return 'hello, '+request.form.get('name', 'little apple')+'. success'
	else:
		return 'hello, '+request.form.get('name', 'little apple')+'. failed'

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

client

import requests
#Upload 01.jpg under the current directory to the server
files = {'image01': open('01.jpg', 'rb')}  
user_info = {'name': 'letian'}  
r = requests.post("http://127.0.0.1:5000/upload", data=user_info, files=files)


#coding=utf-8
from flask import Flask
from flask import request
app = Flask(__name__)

#Routing means that url/register only accepts POST methods. You can also modify the methods parameter as needed

@app.route("/login", methods=["GET", "POST"])
def hello_str():
	if request.method == "POST":
		print(request.headers) #Request header
		#Multiple methods of receiving data
		username = request.form['username']
		username = request.form.get("username",type = str,default="admin") #Get form data
		#Corresponding request requests.post(url, json.dumps(params)) as_text=True becomes Unicode use json.loads() conversion dictionary
		params = request.get_data(as_text=True) 
		params = request.get_json()
		params = request.data
	elif request.method == "GET":

		username = request.args.get("username") #Get get request parameters
		username = request.values.get("username") #Get all requested parameters
	return redirect(url_for('home',username=request.form['username']))

@app.route('/home')
def home():
	return render_template('home.html', username=request.args.get('username'))

if __name__ == "__main__":
	#To control the size of the upper production file, you can set the size of the request entity, file
	app.config['MAX_CONTENT_LENGTH'] = 16 * 1024 * 1024 #16MB
	app.debug = True
	app.run('0.0.0.0',80)

#post request

import requests, json user_info = {'name': 'letian'}
headers = {'content-type': 'application/json'}
r = requests.post("http://127.0.0.1:5000/json", data=json.dumps(user_info), headers=headers)
print r.headers
print r.json()

Build corresponding parameters and set corresponding parameters to return
from flask import Flask,url_for,request,render_template,redirect,session,make_response
@app.route('/login', methods=['POST', 'GET'])
def login():
	if request.method == 'POST':
		...
	if 'user' in session:
		...
	else:
		title = request.args.get('title', 'Default')
		response = make_response(render_template('login.html', title=title), 200)
		response.headers['key'] = 'value'
		return response
if __name__ == "__main__":
	app.run(debug=True)

request related properties

form receives POST/PUT request data, MultiDict
 Targets multidict such as searchword= request.args.get ('key', '')
values can replace form and args
 Cookies requested by cookies, type of which is dict
 headers request header, type is dict
 Data contains the requested data, which is converted to a string, and cannot handle mimetype
 Files multidict with files uploaded by POST/PUT request
 Environ WSGI environment configuration
 Method request method, such as GET,POST
 Path get request file path
 base_url get domain name and request file path
 url get all URLs
 url_root get domain name
 blueprint name
 Endpoint endpoint match request
 JSON if the mimetype is application/json, it will parse JSON. If it is not, it will return None instead of get_json()
MAX_CONTENT_LENGTH back to Max_ CONTENT_ Configuration key for length

view_args = None a dictionary that matches the view parameter of the request. When an exception occurs during the matching, None will be returned.
get_json(force=False, silent=False, cache=True)

The lower one should not be used. Carry it
on_json_loading_failed(e)
Module if the request is sent to an actual module, this parameter returns the name of the current module. This is a deprecated feature, replaced by blueprints.
routing_exception = None if the matching URL fails, this exception will / has been thrown as part of the request processing. This is usually used for NotFound exceptions or similar situations.
url_rule = None internal rule matches the requested URL. This can be used to check whether the method allows before / after the URL( request.url_ rule.methods )Wait.  
By default, write "print" (' request.url_ rule.methods ', request.url_ rule.methods )
Will print:
request.url_rule.methods {'GET', 'OPTIONS', 'HEAD'}

Tags: Programming Session JSON Python pip

Posted on Sat, 30 May 2020 06:25:12 -0400 by gwledig