基础知识
# 1. 导入Flask类；
from flask import Flask
# 2. 实例化一个Flask对象，
# __name__是模块的名称或者包的名称
# 作用: 根据这个参数确定flask应用的路径， 从而快速查找模板和html文件的默认路径；
# 模块就是python文件; 包就是目录(跟普通目录多加一个__init__.py);
#
app = Flask(__name__)
# 3-1.基本路由:通过路由绑定一个视图函数
# @app.route('/'): 告诉Flask哪个URL才能出发对应的函数， 又称为路由;
# 对应定义了一个视图函数， 也就是返回给用户浏览器显示的内容;
# http://www.westos.org/login/
@app.route('/')
def index():
return "<h1>hello world</h1>"
@app.route('/login/')
def login():
return "login"
# 4. 运行Flask应用， 可以指定ip和端口；
# '0.0.0.0' 所有的IP都可以访问到;
app.run()
路由与变量规则
from flask import Flask, request
app = Flask(__name__)
# http:ww.douban.org/123457677/comments/
# http:ww.douban.org/123457673/comments/
# http:ww.douban.org/123457674/comments/
# http:ww.douban.org/123457675/comments/
# 常见路由的规则
# 1. url的一部分可以标记为变量<变量名>
# 2. flask中路由里面的变量常见类型:
# int, string, float, path, uuid
@app.route('/<int:id>/comments/')
def comment1(id):
return "Comment id: %s" %(id)
@app.route('/welcome/<string:user>/')
def welcome(user):
app.logger.debug('this is a debug') # 日志，记录异常信息
app.logger.warning('this is a warn')
return user + "用户, 欢迎来到westos"
# 特殊的url地址: http://www.baidu.com/query?id=123&name=westos
@app.route('/query')
def query():
# 获取url地址里面key值对应的value值;
id = request.args.get('id')
name = request.args.get('name')
return "id: %s, name: %s" %(id, name)
app.run()
URL构建与反向URL
from flask import Flask, request, url_for
app = Flask(__name__)
@app.route('/welcome/<string:user>/')
def welcome(user):
return user + "用户, 欢迎来到westos"
@app.route('/path/')
def path():
print(request.headers)
# 查看默认url地址的请求方法;
# methods is a list of methods this rule should be limited
# to (``GET``, ``POST`` etc.). By default a rule
# just listens for ``GET``
print(request.method)
# url_for: 根据函数名, 反向生成url地址
print("用户正在访问url地址:%s" % (url_for(endpoint="welcome", user="westos")))
return "用户正在访问url地址:%s" % (url_for(endpoint="welcome", user="westos"))
app.run(port=5001)
模板引擎
什么是Jinja2模板引擎?
python的Web开发中， 业务逻辑(实质就是视图函数的内容)和页面逻辑(html 文件)分开的， 使得代码的可读性增强， 代码容易理解和维护；
模板渲染: 在html文件中，通过动态赋值 ， 将重新翻译好的html文件(模板引擎生效) 返回给用户的过程。 其他的模板引擎: Mako, Template, Jinja2
# Jinja2变量显示语法: {{ 变量名 }}
# for循环:
{% for i in li%}
{% endfor %}
# if语句
{% if user == 'westos'%}
{% elif user == 'hello' %}
{% else %}
{% endif%}
变量显示
from flask import Flask, render_template
app = Flask(__name__)
class User(object):
def __init__(self, name, passwd):
self.name = name
self.passwd = passwd
def __str__(self):
return "<User: %s>" %(self.name)
@app.route('/')
def index1():
name = "这是一个消息"
li = [1, 2, 4, 5]
d = dict(a=1, b=2)
u = User("westos", "passwd")
return render_template('index1.html',
name = name,
li = li,
d = d,
u = u
)
app.run(port=5003)
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<p>变量:</p> {{ name }}
<p>列表:</p> {{ li }}
/*依次遍历列表的每一个元素*/
{% for i in li %}
<br/> 列表元素显示: {{ i }}
{% endfor %}
<p>字典:</p> {{ d }}
<p>字典:</p> {{ d.a }}
<p>字典:</p> {{ d['a'] }}
<p>字典:</p> {{ d.b }}
<p>字典:</p> {{ d['b']}}
<p>对象:</p> {{ u }}
<table>
<tr>
<th>用户名</th>
<th>密码</th>
</tr>
<tr>
<td>{{ u.name }}</td>
<td>{{ u.passwd }}</td>
</tr>
</table>
</body>
</html>
过滤器与自定义过滤器
import time
from flask import Flask, render_template
app = Flask(__name__)
class User(object):
def __init__(self, name, passwd):
self.name = name
self.passwd = passwd
def __str__(self):
return "<User: %s>" % (self.name)
# 自定义一个转换时间格式的过滤器
@app.route('/')
def index2():
name = " this is a message"
li = [1, 2, 4, 5]
d = dict(a=1, b=2)
liDict = [
{
'count': 100,
'price': 30
},
{
'count': 110,
'price': 20
},
]
u = User("westos", "passwd")
timestamp = time.time()
return render_template('index2.html',
name=name,
li=li,
d=d,
u=u,
liDict=liDict,
timestamp=timestamp
)
def format_date(value, format="%Y-%m-%d %H:%M:%S"):
# 时间戳----> 元组
ttime = time.localtime(value)
# 元组 --- > 指定字符串
return time.strftime("%Y-%m-%d %H:%M:%S", ttime)
app.add_template_filter(format_date, 'format_date')
@app.route('/index3/')
def index3():
return render_template('index3.html',
timestamp=time.time())
app.run(port=5004)
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
/*什么是过滤器?
实质上就是一个转换函数/方法
*/
<br>
{{ timestamp }}
{{ timestamp | format_date }}
<br>
/*常见的字符串过滤器操作:*/
<ul>
<li>{{ name | upper }}</li>
<li>{{ name | lower }}</li>
<li>{{ "hello" | capitalize }}</li>
<li>{{ " hello world" | capitalize }}</li>
<li>{{ name | reverse }}</li>
</ul>
/*常见数值操作*/
<ul>
<!--四舍五入-->
<li>{{ -12.9623423435 | round }}</li>
<li>{{ -12.9623423435 | round | abs }}</li>
</ul>
/*列表常见:*/
<ul>
<li>{{ li }}</li>
<li>{{ li | first }}</li>
<li>{{ li | last }}</li>
<li>{{ li | length }}</li>
<li>{{ li | sum }}</li>
<li>{{ li | sort | reverse }}</li>
<li>{{ li | join(":") }}</li>
<li>{{ ["hello", "world"] | upper}}</li>
<li>{{ ["hello", "woHld"] | lower}}</li>
</ul>
/*列表包含字典常用操作:*/
<ul>
{% for item in liDict | sort(attribute='price', reverse=false) %}
{{ item }}
{% endfor %}
</ul>
</body>
</html>
模板的继承
模板继承语法:
1. 如何继承某个模板?
{% extends "模板名称" %}
2. 如何挖坑和填坑?
挖坑:
{% block 名称 %}
默认值
{% endblock %}
填坑:
{% block 名称 %}
{% endblock %}
3. 如何调用/继承被替代的模板?
挖坑:
{% block 名称 %}
默认值
{% endblock %}
填坑:
{% block 名称 %}
#如何继承挖坑时的默认值?
{{ super() }}
# 后面写新加的方法.
........
{% endblock %}
常见http方法之post与get
# 1. 常见HTTP请求方法:
GET: 1). 获取信息 2). 提交的信息会展示在url: http://www.wewtos.org/login?user=westos&passwd=westos
POST:1). 提交信息, 不在url里面展示, 有利于数据的安全性;
# 2. 默认路由接受的请求方法为_____get____?
如何指定接收多个HTTP请求方法? __@app.route('/login/', methods=['GET', 'POST'])____________________.
路由: @app.route('/login/', methods=['GET', 'POST'])
视图函数: def login():
# 3. 如何判断用户请求的HTTP方法? request.method
如何获取用户POST请求提交的表单数据? request.form['user']
# 4.模板渲染(jinja2):
why? python中生成html不易修改与维护, 所以将html的内容独立到templates目录中;
how?
1). 去当前项目目录下寻找templtes是否存在?再去判断templates目录下是否有login.html文件?
2). 读取这个login.html文件的内容, 作为render_template的返回值;
3). 最终返回给用户浏览器;
render_template('login.html')
# 5. 重定向和错误?
redirect
return render_template('login.html', message="用户名或者密码错误")
# 6. 404处理
from flask import Flask, request, render_template, redirect, url_for, abort
# redirect
app = Flask(__name__)
@app.route('/')
def index():
return render_template('index.html')
@app.route('/login/', methods=['GET', 'POST'])
def login():
if request.method == 'POST':
print(request.form)
# 1. 如何获取到用户提交的信息呢?
user = request.form['user']
passwd = request.form['passwd']
# 2. 判断用户名和密码是否正确
if user == 'root' and passwd =='westos':
# 如果登陆成功, 跳转到主页;
return redirect(url_for('index'))
else:
# 如果登陆失败, 重新登陆;
return render_template('login.html', message="用户名或者密码错误")
else:
# 用户是GET请求, 返回登陆的html页面
# 1. 读取login.html文件的内容
# 2. 将读取的内容返回给用户界面
return render_template('login.html')
# 404异常处理： 类似于捕获异常
@app.errorhandler(404)
def not_found(e):
return render_template('404.html')
# 抛出异常
@app.route('/user/<int:user_id>/')
def user(user_id):
if 0<int(user_id)<=100:
return "欢迎访问: %s" %(user_id)
else:
abort(404)
app.run(port=5002)
session操作
# cookie: 客户端浏览器的缓存；
# session: 服务端服务器的缓存;
Session 对象存储特定用户会话所需的属性及配置信息。这样，当用户在应用程序的 Web 页之间跳转时，
存储在 Session 对象中的变量将不会丢失，而是在整个用户会话中一直存在下去。当用户请求来自应用程序的
Web 页时，如果该用户还没有会话，则 Web 服务器将自动创建一个 Session 对象。当会话过期或被放弃后，
服务器将终止该会话。Session 对象最常见的一个用法就是存储用户的首选项。
"""
from flask import Flask, session
import random
app = Flask(__name__)
app.config['SECRET_KEY'] = random._urandom(24)
# 设置是24位的字符， 每次运行服务器的secret_key都是不同的，
# 服务器重启后会清除上一次存储的session信息值;
# 设置session值；
@app.route('/')
def index():
# 如何设置session的key-value值
session['name'] = 'westos'
return "hello world"
@app.route('/get/')
def get():
# 如何获取?
return session.get('name')
@app.route('/delete/')
def delete():
# 如何删除?
print(session.get('name'))
session.pop('name')
print(session.get('name'))
return 'delete'
app.run(port=5001)
判断用户是否登陆的装饰器
import random
import os
from datetime import datetime
import psutil
from flask import Flask, request, render_template, redirect, url_for, abort, session
# redirect
app = Flask(__name__)
app.config['SECRET_KEY'] = random._urandom(24)
usersinfo = [
{'user': 'westos',
'passwd': 'westos'
}
]
import functools
def is_login(f):
"""判断用户是否登陆的装饰器"""
@functools.wraps(f)
def wrapper(*args, **kwargs):
# run函数代码里面， 如果登陆， session加入user， passwd两个key值；
# run函数代码里面， 如果注销， session删除user， passwd两个key值；
# 如果没有登陆成功， 则跳转到登陆界面
if 'user' not in session:
return redirect('/login/')
# 如果用户是登陆状态， 则访问哪个路由， 就执行哪个路由对应的视图函数；
return f(*args, **kwargs)
return wrapper
# 用户主页
@app.route('/')
def index():
return render_template('index.html')
# 用户登陆按钮
@app.route('/login/', methods=['GET', 'POST'])
def login():
if request.method == 'POST':
print(request.form)
# 1. 如何获取到用户提交的信息呢?
user = request.form['user']
passwd = request.form['passwd']
# 2. 判断用户名和密码是否正确
for dbuser in usersinfo:
if user == dbuser['user'] and passwd == dbuser['passwd']:
# 将用户名和密码信息存储到session中;
session['user'] = user
session['passwd'] = passwd
# 如果登陆成功, 跳转到主页;
return redirect(url_for('index'))
else:
# 如果登陆失败, 重新登陆;
return render_template('login.html', message="用户名或者密码错误")
else:
# 用户是GET请求, 返回登陆的html页面
# 1. 读取login.html文件的内容
# 2. 将读取的内容返回给用户界面
return render_template('login.html')
# 用户注销
@app.route('/logout/')
def logout():
session.pop('user', None)
session.pop('passwd', None)
# 注销即删除用户的session信息， 注销成功， 跳转到首页;
return redirect(url_for('index'))
# return redirect('/')
# 用户注册# http方法: get, post(需要提交用户名和密码信息)
@app.route('/register/', methods=['GET', 'POST'])
def register():
# 判断是否提交注册信息；
if request.method == 'POST':
user = request.form['user']
passwd = request.form['passwd']
for dbuser in usersinfo:
if user == dbuser['user']:
message = "用户已经存在"
return render_template('register.html', message=message)
else:
# 如果遍历所有的字典， 没有发现与之前的用户名冲突；
# 将用户信息加入列表usersingo中;
# 并且跳转到登陆界面;
usersinfo.append(dict(user=user, passwd=passwd))
return redirect(url_for('login'))
else:
return render_template('register.html')
# 系统监控
@app.route('/sysinfo/')
@is_login
def sysinfo():
info = os.uname()
# 获取开机时间的时间戳， 需要安装psutil模块;
boot_time = psutil.boot_time()
# 将时间戳转换为字符串格式, 两种方法， 任选一种l
# print(time.ctime(boot_time))
boot_time = datetime.fromtimestamp(boot_time)
# 获取当前时间
now_time = datetime.now()
# 获取时间差
delta_time = now_time - boot_time
delta_time = str(delta_time).split('.')[0]
return render_template('sysinfo.html',
hostname = info.nodename,
sysname = info.sysname,
release = info.release,
machine = info.machine,
now_time = now_time,
boot_time = boot_time,
delta_time = delta_time
)
# 404异常处理： 类似于捕获异常
@app.errorhandler(404)
def not_found(e):
return render_template('404.html')
# 抛出异常
@app.route('/user/<int:user_id>/')
def user(user_id):
if 0<int(user_id)<=100:
return "欢迎访问: %s" %(user_id)
else:
abort(404)
app.run(port=5000)
上传文件
# 实现目标: 如何将文件上传到服务器(保存在指定的文件夹)
"""
import os
from flask import Flask, request, render_template
import uuid
app = Flask(__name__)
@app.route('/upload/', methods=['GET', 'POST'])
def upload():
if request.method == 'POST':
# 获取到用户上传的文件对象
f = request.files['faceImg']
print(f.filename)
# 获取当前项目所在目录位置；
basepath = os.path.dirname(__file__)
print(basepath)
# 拼接路径， 存储文件到static/face/xxxx
filename = os.path.join(basepath, 'static/face', f.filename)
# 保存文件
f.save(filename)
return render_template('demo/upload.html', message = "上传成功")
else:
return render_template('demo/upload.html')
app.run(port=6001)
连接数据库操作
import pymysql
from config import DB
# 1. 创建连接
conn = pymysql.connect(
host=DB.HOST,
user = DB.USER,
passwd = DB.PASSWD,
port = DB.PORT,
db = DB.DBNAME,
)
cur = conn.cursor()
def isUserExist(username):
"""判断用户名是否存在"""
sqli = "select * from users where name='%s'" %(username)
res = cur.execute(sqli)
# res返回的是sql语句查询结果的个数；
# 如果为0， 没有查到。
if res == 0:
return False
else:
return True
def isPasswdOk(username, passwd):
sqli = "select * from users where name='%s' and passwd='%s'" %(
username, passwd)
res = cur.execute(sqli)
if res == 0 :
return False
else:
return True
def addUser(username, passwd):
"""用户注册时， 添加信息到数据库中"""
sqli = "insert into users(name, passwd) values('%s', '%s')" %(
username, passwd)
try:
res = cur.execute(sqli)
conn.commit()
except Exception as e:
conn.rollback()
return e
#
# cur.close()
# conn.close()
if __name__ == "__main__":
addUser('root', 'root')
print(isUserExist('root'))
print(isPasswdOk('root', 'root'))
