flask基础根据知了课堂整理

1安装Python2.7：

Mac下使用Python2.7.
Windows下安装Python2.7.
- 从python官网下载python2.7的版本。
- 双击python2.7，然后选择安装路径，一顿下一步就可以了。
- 设置环境变量，把python的安装路径添加到PATH变量中。
- 还需要设置一个环境变量，一定要设置，不然后面就不能正常安装flask了。

2Python虚拟环境介绍与安装：

因为python的框架更新迭代太快了，有时候需要在电脑上存在一个框架的多个版本，这时候虚拟环境就可以解决这个问题。
通过以下命令安装虚拟环境：pip install virtualenv
开辟新的虚拟环境：virtualenv [virtualenv-name]
激活虚拟环境：
- [类linux]：source [虚拟环境的目录]/bin/activate
- [windows]：直接进入到虚拟环境的目录，然后执行activate
- 退出虚拟环境：deactivate

3pip安装flask：

执行activate脚本，进入指定的虚拟环境。
在该虚拟环境中，执行以下命令安装：pip install flask
验证flask是否安装成功：
- 进入python命令行。
import flask
print flask.version

认识url：

如果使用的是http协议，那么浏览器就会使用80端口去请求这个服务器的资源。
如果使用的是https协议，那么浏览器会使用443端口去请求这个服务器的资源。
http://www.jianshu.com/
https://www.baidu.com/
https://www.baidu.com/s?ie=utf-8&f=8

http://baike.baidu.com/link?url=ELcglgxAgFQ9WlMytXEhxu-WBtI7mTlDj3TJ-Ht6ZSecAYt0hgqY0euqaB60opaEEZ7JChin5vUd_YkOgMi7BT5kc3E85ZXeoVL2iVfKZu_jHMcNabK8NXilqnfJknKs

http://baike.baidu.com/link?url=ELcglgxAgFQ9WlMytXEhxu-WBtI7mTlDj3TJ-Ht6ZSecAYt0hgqY0euqaB60opaEEZ7JChin5vUd_YkOgMi7BT5kc3E85ZXeoVL2iVfKZu_jHMcNabK8NXilqnfJknKs#3

http://baike.baidu.com/link?url=ELcglgxAgFQ9WlMytXEhxu-WBtI7mTlDj3TJ-Ht6ZSecAYt0hgqY0euqaB60opaEEZ7JChin5vUd_YkOgMi7BT5kc3E85ZXeoVL2iVfKZu_jHMcNabK8NXilqnfJknKs#5

4URL详解

URL是Uniform Resource Locator的简写，统一资源定位符。

一个URL由以下几部分组成：

scheme://host:port/path/?query-string=xxx#anchor

scheme：代表的是访问的协议，一般为http或者https以及ftp等。
host：主机名，域名，比如www.baidu.com。
port：端口号。当你访问一个网站的时候，浏览器默认使用80端口。
path：查找路径。比如：www.jianshu.com/trending/now，后面的trending/now就是path。
query-string：查询字符串，比如：www.baidu.com/s?wd=python，后面的wd=python就是查询字符串。
anchor：锚点，后台一般不用管，前端用来做页面定位的。

5web服务器和应用服务器以及web应用框架：

web服务器：负责处理http请求，响应静态文件，常见的有Apache，Nginx以及微软的IIS.
应用服务器：负责处理逻辑的服务器。比如php、python的代码，是不能直接通过nginx这种web服务器来处理的，只能通过应用服务器来处理，常见的应用服务器有uwsgi、tomcat等。
web应用框架：一般使用某种语言，封装了常用的web功能的框架就是web应用框架，flask、Django以及Java中的SSH(Structs2+Spring3+Hibernate3)框架都是web应用框架。

在这里插入图片描述

01Flask基础

6第一个flask程序讲解：

第一次创建项目的时候，要添加flask的虚拟环境。添加虚拟环境的时候，一定要选择到python这个执行文件。
比如你的flask的虚拟环境的目录在/User/Virtualenv/flask-env/bin/python。

flask程序代码的详细解释：

# 从flask这个框架中导入Flask这个类
from flask import Flask

# 初始化一个Flask对象
# Flaks()
# 需要传递一个参数__name__
# 1. 方便flask框架去寻找资源
# 2. 方便flask插件比如Flask-Sqlalchemy出现错误的时候，好去寻找问题所在的位置
app = Flask(__name__)


# @app.route是一个装饰器
# @开头，并且在函数的上面，说明是装饰器
# 这个装饰器的作用，是做一个url与视图函数的映射
# 127.0.0.1:5000/   ->  去请求hello_world这个函数，然后将结果返回给浏览器
@app.route('/')
def hello_world():
    return '我是第一个flask程序'


# 如果当前这个文件是作为入口程序运行，那么就执行app.run()
if __name__ == '__main__':
    # app.run()
    # 启动一个应用服务器，来接受用户的请求
    # while True:
    #   listen()
    app.run()

7设置debug模式：

在app.run()中传入一个关键字参数debug,app.run(debug=True)，就设置当前项目为debug模式。
debug模式的两大功能：
- 当程序出现问题的时候，可以在页面中看到错误信息和出错的位置。不然网页只会现实internal server error
- 只要修改了项目中的python文件，程序会自动加载，不需要手动重新启动服务器。

8使用配置文件：

新建一个config.py文件
在主app文件中导入这个文件，并且配置到app中，示例代码如下：

 比如上一步写的 app.run(debug=True)
    可以直接在在config.py内写   DEBUG=True
    app.py中仍是app.run()

但是要在app.py要引入
    import config
    app.config.from_object(config)

还有许多的其他参数，都是放在这个配置文件中，比如SECRET_KEY和SQLALCHEMY这些配置，都是在这个文件中。

9url传参数：

参数的作用：可以在相同的URL，但是指定不同的参数，来加载不同的数据。

在flask中如何使用参数：

@app.route('/article/<id>')
def article(id):
    return u'您请求的 参数是：%s' % id

在这里插入图片描述
如图传进去的是这样的id
* 参数需要放在两个尖括号中。
* 视图函数中需要放和url中的参数同名的参数。
效果如下

10反转URL：

什么叫做反转URL：从视图函数到url的转换叫做反转url
反转url的用处：
- 在页面重定向（redirect）的时候，会使用url反转。
- 在模板中，也会使用url反转。

在这里插入图片描述

通过视图函数my_list和article 来找到他们的url 效果如下在这里插入图片描述

11页面跳转和重定向：

用处：在用户访问一些需要登录的页面的时候，如果用户没有登录，那么可以让她重定向到登录页面。

代码实现：

from flask import redirect,url
redirect(url_for('login'))

点击发布问答的时候如果登录的时候就可以发布问答
没有登陆的话就要重定向去登录
简单模拟效果如下：
在这里插入图片描述

@app.route('/question/<is_login>/')   # <is_login>是参数
def question(is_login):
    if(is_login):
        return u"这是发布问答页面"
    else:
        return redirect(url_for('login'))

效果：传入1表示登录 0表示未登录
在这里插入图片描述

02模板笔记

12Flask渲染Jinja2模板和传参：

如何渲染模板：
- 模板放在templates文件夹下
- 从flask中导入render_template函数。
- 在视图函数中，使用render_template函数，渲染模板。注意：只需要填写模板的名字，不需要填写templates这个文件夹的路径。(仅仅限html直接在template文件夹下)
模板传参：
- 如果只有一个或者少量参数，直接在render_template函数中添加关键字参数就可以了。
  如：

@app.route('/')
def index():
    return render_template('index.html',usename=u'黄勇')#传参

如果有多个参数的时候，那么可以先把所有的参数放在字典中，然后在render_template中，
使用两个星号，把字典转换成关键参数传递进去，这样的代码更方便管理和使用。

@app.route('/')
def index():
      
    context={
        'username': u'黄勇',
        'gender':'男',

    }
    return render_template('index.html',**context)#传参

页面显示如下：
在这里插入图片描述
在index.html中描写如下：

在模板中，如果要使用一个变量，语法是：{{params}}
访问模型中的属性或者是字典，可以通过{{params.property}}的形式，或者是使用{{params['age']}}.

def index():
    class Person(object):
        name=u'喜喜'
        age=18
    P=Person()


    context={
        'username': u'黄勇',
        'gender':'男',
        'person':P,
        'websites':{
            'baidu':'www.baidu.',
            'google':'www.google',

        }

    }
    return render_template('index.html',**context)#传参

html如下：

<body>
<p> 用户名：{{ username }}</p>
<p> 性别：{{ gender }}</p>
<hr>
<p>名字：{{ person.name }}</p>
<p>年龄：{{ person.age }}</p>

<hr>
<p>百度：{{ websites.baidu}}</p>
</body>

13if判断：

语法：
```
{% if xxx %}
{% else %}
{% endif %}
```
if的使用，可以和python中相差无几。
实现简单的登录时右上角显示“xxxx（用户名），注销”的功能：

在这里插入图片描述
登录了：
没登录：

14for循环遍历列表和字典：

字典的遍历，语法和python一样，可以使用items()、keys()、values()、iteritems()、iterkeys()、itervalues()
```
{% for k,v in user.items() %}
    <p>{{ k }}：{{ v }}</p>
{% endfor %}
```

python中的用法 k、v分别指代key和value 在这里插入图片描述
同理 html里面用法一样只是k v是变量要用{{k}} ：{{v}} 表示

效果：

列表的遍历：语法和python一样。

{% for website in websites %}
    <p>{{ website }}</p>
{% endfor %}

在这里插入图片描述
小例子：

<table>
    <thead>
    <TH>书名</TH>
    <th>作者</th>
    <th>价格</th>
    </thead>
    <tbody>
    {% for book in books %}
        <tr>
        <td>{{ book.name }}</td>
        <td>{{ book.author }}</td>
        <td>{{ book.price }}</td>
        </tr>

    {% endfor %}
    </tbody>
</table>

@app.route('/test/')
def test():
    books=[
        {
            'name':u'西游记',
            'author': u'吴承恩',
            'price': 109

        },
        {
            'name': u'红楼梦',
            'author': u'曹雪芹',
            'price': 99

        },
        {
            'name': u'三国演义',
            'author': u'罗贯中',
            'price': 88

        },

    ]
    return render_template('test.html',books=books)

在这里插入图片描述

16过滤器：

在这里插入图片描述
过滤器作用：有头像显示头像没头像显示默认的图片

介绍和语法：
- 介绍：过滤器可以处理变量，把原始的变量经过处理后再展示出来。作用的对象是变量。
- 语法：
```
{{ avatar|default('xxx') }}#  |是管道符号
```
default过滤器：如果当前变量不存在，这时候可以指定默认值。
length过滤器：求列表或者字符串或者字典或者元组的长度。
比如评论求长括号内显示有几条

操作如下：

效果如下没传头像时候是默认头像评论数长度是两条在这里插入图片描述

常用的过滤器：
abs(value)：返回一个数值的绝对值。示例：-1|abs
default(value,default_value,boolean=false)：如果当前变量没有值，则会使用参数中的值来代替。示例：name|default(‘xiaotuo’)——如果name不存在，则会使用xiaotuo来替代。boolean=False默认是在只有这个变量为undefined的时候才会使用default中的值，如果想使用python的形式判断是否为false，则可以传递boolean=true。也可以使用or来替换。
escape(value)或e：转义字符，会将<、>等符号转义成HTML中的符号。示例：content|escape或content|e。
first(value)：返回一个序列的第一个元素。示例：names|first
format(value,*arags,**kwargs)：格式化字符串。比如：

{{ “%s” - “%s”|format(‘Hello?’,“Foo!”) }}
将输出：Helloo? - Foo!
last(value)：返回一个序列的最后一个元素。示例：names|last。

length(value)：返回一个序列或者字典的长度。示例：names|length。
join(value,d=u’’)：将一个序列用d这个参数的值拼接成字符串。
safe(value)：如果开启了全局转义，那么safe过滤器会将变量关掉转义。示例：content_html|safe。
int(value)：将值转换为int类型。
float(value)：将值转换为float类型。
lower(value)：将字符串转换为小写。
upper(value)：将字符串转换为小写。
replace(value,old,new)：替换将old替换为new的字符串。
truncate(value,length=255,killwords=False)：截取length长度的字符串。
striptags(value)：删除字符串中所有的HTML标签，如果出现多个空格，将替换成一个空格。
trim：截取字符串前面和后面的空白字符。
string(value)：将变量转换成字符串。
wordcount(s)：计算一个长字符串中单词的个数。

17继承和block：

继承的作用如下图导览条位置都是相同的在这里插入图片描述

所以可以把导航条内容都放在base里面之后再去继承
1.继承作用和语法：
python中的继承
* 作用：可以把一些公共的代码放在父模板中，避免每个模板写同样的代码。
* 语法：
子模板写 {% extends 'base.html' %}
在父模板中写

{% block main%}{% endblock %}

block实现：
- 作用：可以让子模板实现一些自己的需求。父模板需要提前定义好。相当于父模板定义一个接口然后让子模板实现

注意点：字模板中的代码，必须放在block块中。可以有多个block

{% extends 'base.html' %}
{% block main%}
<h1>
    这是首页啊啊
</h1>
{% endblock %}

父模板：在这里插入图片描述
子模板：

18url链接：

使用url_for(视图函数名称)可以反转成url。
url_for(‘login’)

等价于’/login/’

19加载静态文件：

语法：url_for('static',filename='路径')
静态文件，flask会从static文件夹中开始寻找，所以不需要再写static这个路径了。

可以加载css文件，可以加载js文件，还有image文件。(CSS内放一些背景字体的设置 js放警告框之类)

第一个：加载css文件
<link rel="stylesheet" href="{{ url_for('static',filename='css/index.css') }}">
第二个：加载js文件
<script src="{{ url_for('static',filename='js/index.js') }}"></script>
第三个：加载图片文件
<img src="{{ url_for('static',filename='images/zhiliao.png') }}" alt="">

20 Mac和Windows下数据库的安装：

Mysql为例
https://dev.mysql.com/downloads/mysql/
Mac上安装Mysql很简单，直接一顿下一步安装就可以了。
设置初始化密码的命令是：
```
mysqladmin -uroot password [password]
```
windows:
*. 如果没有安装.net Framework 4，就在那个提示框中，找到下载的url，下载下来，安装即可。
*. 如果没有安装Microsoft Visual C++ x64，那么就需要谷歌或者百度下载这个软件进行安装即可。

21MySQL-python中间件的介绍与安装：

如果是在类unix系统上，直接进入虚拟环境，输入sudo pip install mysql-python。
如果是在windows系统上，那么在这里下载http://www.lfd.uci.edu/~gohlke/pythonlibs/#mysql-python下载MySQL_python‑1.2.5‑cp27‑none‑win_amd64.whl，然后在命令行中，进入到MySQL_python‑1.2.5‑cp27‑none‑win_amd64.whl所在的目录，输入以下命令进行安装：
```
pip install MySQL_python‑1.2.5‑cp27‑none‑win_amd64.whl
```

注意：1.Mysql驱动:

eg:mysql-connector-odbc-5.1.5-win32.msi

2.Python安装模块

Python2.x 版本要安装mysql-python，而Python3.x版本要安装 mysqlclient ！

具体操作如链接：

https://blog.csdn.net/weixin_40947719/article/details/86323073。
所以我们要安装mysqlclient

先看

22Flask-SQLAlchemy的介绍与安装：

ORM：Object Relationship Mapping（模型关系映射）。
flask-sqlalchemy是一套ORM框架。
ORM的好处：可以让我们操作数据库跟操作对象是一样的，非常方便。因为一个表就抽象成一个类，一条数据就抽象成该类的一个对象。
安装flask-sqlalchemy：sudo pip install flask-sqlalchemy。

在这里插入图片描述

23Flask-SQLAlchemy的使用：

初始化和设置数据库配置信息：
- 使用flask_sqlalchemy中的SQLAlchemy进行初始化：
```
from flask_sqlalchemy import SQLAlchemy
app = Flask(__name__)
db = SQLAlchemy(app)
```

设置配置信息：在config.py文件中添加以下配置信息：

# dialect+driver://username:password@host:port/database
DIALECT = 'mysql'
DRIVER = 'mysqldb'
USERNAME = 'root'
PASSWORD = 'root'
HOST = '127.0.0.1'
PORT = '3306'
DATABASE = 'db_demo1'

SQLALCHEMY_DATABASE_URI = "{}+{}://{}:{}@{}:{}/{}?charset=utf8".format(DIALECT,DRIVER,USERNAME,PASSWORD,HOST
                                             ,PORT,DATABASE)

SQLALCHEMY_TRACK_MODIFICATIONS = False

在主app文件中，添加配置文件：

app = Flask(__name__)
app.config.from_object(config)
db = SQLAlchemy(app)

做测试，看有没有问题：
```
db.create_all()
```
如果没有报错，说明配置没有问题，如果有错误，可以根据错误进行修改。

24使用Flask-SQLAlchemy创建模型与表的映射：

一张表就是一个模型

模型需要继承自db.Model，然后需要映射到表中的属性，必须写成db.Column的数据类型。
数据类型：
- db.Integer代表的是整形.
- db.String代表的是varchar，需要指定最长的长度。
- db.Text代表的是text。
其他参数：
- primary_key：代表的是将这个字段设置为主键。
- autoincrement：代表的是这个主键为自增长的。
- nullable：代表的是这个字段是否可以为空，默认可以为空，可以将这个值设置为False，在数据库中，这个值就不能为空了。

在这里插入图片描述

   class Article(db.Model):
    __tablename__='article'
    id=db.Column(db.Integer,primary_key=True,autoincrement=True)
    title=db.Column(db.String(100),nullable=False)
    content=db.Column(db.Text,nullable=False)

db.create_all()

cmd中

create database test_demo charset utf8
use test_demo;
 show tables;

 __tablename__   加下划线表示被保护字段

在数据库应用中，我们经常需要用到自动递增的唯一编号来标识记录。在MySQL中，可通过数据列的auto_increment属性来自动生成。可在建表时可用“auto_increment=n”选项来指定一个自增的初始值。可用“alter table table_name auto_increment=n”命令来重设自增的起始值，当然在设置的时候Mysql会取数据表中auto_increment列的最大值 + 1与n中的较大者作为新的auto_increment值。

最后需要调用db.create_all来将模型真正的创建到数据库中。

25Flask-SQLAlchemy数据的增、删、改、查：通过session字段

增：



# 增加：
article1 = Article(title='aaa',content='bbb')
db.session.add(article1)
# 事务
db.session.commit()

查：

 
# select * from article where article.title='aaa';
article1 = Article.query.filter(Article.title == 'aaa').first()
#没有first（）的话 返回的是一个query对象 相当于一个list 其实 Article.query.filter(Article.title == 'aaa')的地层就是sql语句 select * from article where article.title='aaa';
print 'title:%s' % article1.title
print 'content:%s' % article1.content

改：

# 改：
# 1. 先把你要更改的数据查找出来
article1 = Article.query.filter(Article.title == 'aaa').first()
# 2. 把这条数据，你需要修改的地方进行修改
article1.title = 'new title'
# 3. 做事务的提交
db.session.commit()

删：

# 删
# 1. 把需要删除的数据查找出来
article1 = Article.query.filter(Article.content == 'bbb').first()
# 2. 把这条数据删除掉
db.session.delete(article1)
# 3. 做事务提交
db.session.commit()

cmd中

create database test_demo charset utf8
use test_demo;
 show tables;
select * from article;

26Flask-SQLAlchemy外键及其关系：

1.外键：

```
class User(db.Model):
    __tablename__ = 'user'
    id = db.Column(db.Integer,primary_key=True,autoincrement=True)
    username = db.Column(db.String(100),nullable=False)

class Article(db.Model):
    __tablename__ = 'article'
    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    title = db.Column(db.String(100),nullable=False)
    content = db.Column(db.Text,nullable=False)
    author_id = db.Column(db.Integer,db.ForeignKey('user.id'))

    author = db.relationship('User',backref=db.backref('articles'))#重点新加的 为了方便访问谋篇文章的作者
```

author = db.relationship('User',backref=db.backref('articles'))解释：
- 给Article这个模型添加一个author属性，可以访问这篇文章的作者的数据，像访问普通模型一样。第一个参数User是模型名字，他会关联到Article中和User中有关的外键。
- backref是定义反向引用，可以通过User.articles访问这个模型所写的所有文章。即可以用过author访问这个作者的所有文章

如上图访问aaa这篇文章的作者现在只需要两行代码
打印结果：username：zhiliao

config.py如下：在这里插入图片描述

在这里插入图片描述

//如上如果想要找文章标题为aaa的作者就先要找文章标题为aaa的article 用这个article找这个文章的作者id
再用这个作者id去user中找user.name 这样过于麻烦

希望可以方便的使用如下直接用article.author找到作者如果想要找这个作者其他的文章可以用后面两句

在这里插入图片描述
如果需要在表中添加新的字段比如在user中添加password的字段你需要新建先drop tables user;然后才能db.create_all() 否则mysql不会显示新的字段因为db.create_all() 只能被创建一次

在这里插入图片描述

如上图： article.author=User.query.filter(User.id==1).first()
可以替代article=Article（author.id==1）

打印结果：在这里插入图片描述

2.多对多：
在这里插入图片描述
如上图以sql语句为例 article_tag为中间表

以下为对应的模型记得添加relationship 使得三张表可以产生关联因为需要中间表所以有了 secondary=article_tag
在这里插入图片描述

article_tag为中间表在这里插入图片描述

* 多对多的关系，要通过一个中间表进行关联。
* 中间表，不能通过`class`的方式实现，只能通过`db.Table`的方式实现。
* 设置关联：`tags = db.relationship('Tag',secondary=article_tag,backref=db.backref('articles'))`需要使用一个关键字参数`secondary=中间表`来进行关联。
* 访问和数据添加可以通过以下方式进行操作：
* 因为一篇文章可以使用多种标签 每种标签也可以被多篇文章使用
    - 添加数据：
        ```
        article1 = Article(title='aaa')
        article2 = Article(title='bbb')

        tag1 = Tag(name='111')
        tag2 = Tag(name='222')

        article1.tags.append(tag1)
        article1.tags.append(tag2)

        article2.tags.append(tag1)
        article2.tags.append(tag2)

        db.session.add(article1)
        db.session.add(article2)

        db.session.add(tag1)
        db.session.add(tag2)

        db.session.commit()
        ```
    - 访问数据：访问标题为aaa文章内的所有标签的标签名字
        ```
        article1 = Article.query.filter(Article.title == 'aaa').first()
        tags = article1.tags
        for tag in tags:
            print tag.name
打印结果：
111
222
        ```

在这里插入图片描述

27Flask-Script的介绍与安装：

Flask-Script：Flask-Script的作用是可以通过命令行的形式来操作Flask。例如通过命令跑一个开发版本的服务器、设置数据库，定时任务等。
安装：首先进入到虚拟环境中，然后pip install flask-script来进行安装。
如果直接在主manage.py中写命令，那么在终端就只需要python manage.py command_name就可以了。
如果把一些命令集中在一个文件中，那么在终端就需要输入一个父命令，比如python manage.py db init。

例子：
模仿manage.py 以下为manage.py文件：

from flask_script import Manager
from flask_script_demo import app
from db_scripts import DBManager
manager = Manager(app)
# 和数据库相关的操作，我都放在一起  
@manager.command   #此为装饰器
def runserver():
    print '服务器跑起来了!!!!!'
    
manager.add_command('db',DBManager)
#db是命令前缀   cmd输入 python manage.py db init
#cmd中显示"数据库完成初始化"

if __name__ == '__main__':
    manager.run()

效果如下
在这里插入图片描述

有子命令的例子：

db_scripts文件：
#encoding: utf-8

from flask_script import Manager

DBManager = Manager()

@DBManager.command
def init():
    print '数据库初始化完成'

@DBManager.command
def migrate():
    print '数据表迁移成功'

28分开`models`以及解决循环引用：

在这里插入图片描述

如上图出现循环引用将其修改为以下部分
在这里插入图片描述

分开models的目的：为了让代码更加方便的管理。
如何解决循环引用：把db放在一个单独的文件中（exts），切断循环引用的线条就可以了。

exts.py 在这里插入图片描述

models_sep.py（相当于app.py文件)
其中db.init_app(app) 相当于db=SQLAlchemy（）绑定了这个app 在这里插入图片描述

Model.py
在这里插入图片描述

29Flask-Migrate的介绍与安装：

exts.py
在这里插入图片描述

Models.py
在这里插入图片描述
migrate_demo.py

如果没有
with app.app_context()://手动将app推到app栈中
   db.create_all();

即使有db.init_app(app)绑定也会不会访问到这个app，
因为没有访问视图函数相当于没有访问这个服务器 ，
这时候这个app并不在app栈中， 
所以db.init_app(app) db访问不到app如下图  。
所以需要用with app.app_context() 手动将app推到app上下文的这个栈中

在这里插入图片描述

介绍：因为采用db.create_all在后期修改字段的时候，不会自动的映射到数据库中，必须删除表，然后重新运行db.craete_all才会重新映射，这样不符合我们的需求。(因为之前有的数据都会被清空,不符合实际需求)因此flask-migrate就是为了解决这个问题，她可以在每次修改模型后，可以将修改的东西映射到数据库中。
首先进入到你的虚拟环境中，然后使用pip install flask-migrate进行安装就可以了。（或者直接在pycharm的setting的python interpreter中安装）
使用flask_migrate必须借助flask_scripts，这个包的MigrateCommand中包含了所有和数据库相关的命令。
flask_migrate相关的命令：
第一步 * python manage.py db init：初始化一个迁移脚本的环境，只需要执行一次。
第二步 * python manage.py db migrate：将模型生成迁移文件，只要模型更改了，就需要执行一遍这个命令。
第三步 * python manage.py db upgrade：将迁移文件真正的映射到数据库中。每次运行了migrate命令后，就记得要运行这个命令。
注意点：需要将你想要映射到数据库中的模型，都要导入到manage.py文件中，如果没有导入进去，就不会映射到数据库中。

manage.py的相关代码：

from flask_script import Manager
from migrate_demo import app
from flask_migrate import Migrate,MigrateCommand
from exts import db
from models import Article#要把需要映射的模型导入

# init  这样会在左侧产生一个migration文件夹
# migrate  将Article这个模型生成迁移文件
# upgrade  把迁移文件真的映射到表中
# 模型  ->  迁移文件  ->  表

manager = Manager(app)

# 1. 要使用flask_migrate，必须绑定app和db
migrate = Migrate(app,db)

# 2. 把MigrateCommand命令添加到manager中
manager.add_command('db',MigrateCommand)

if __name__ == '__main__':
    manager.run()

在cmd中venv虚拟环境下的命令：
python manage.py db.init
python manage.py db migrate
python manage.py db upgrade

注意：当在model.py中的类添加了新的行记录时候 
之后就进行migrate和upgrade即可不用init 

且用了migrate相关命令后就不用
 with app.app_context():
   db.create_all();

30 cookie和session

cookie：

cookie出现的原因：在网站中，http请求是无状态的。也就是说即使第一次和服务器连接后并且登录成功后，第二次请求服务器依然不能知道当前请求是哪个用户。cookie的出现就是为了解决这个问题，第一次登录后服务器返回一些数据（cookie）给浏览器，然后浏览器保存在本地，当该用户发送第二次请求的时候，就会自动的把上次请求存储的cookie数据自动的携带给服务器，服务器通过浏览器携带的数据就能判断当前用户是哪个了。
如果服务器返回了cookie给浏览器，那么浏览器下次再请求相同的服务器的时候，就会自动的把cookie发送给浏览器，这个过程，用户根本不需要管。
cookie是保存在浏览器中的，相对的是浏览器。
注意：cookie是存储数据的一种格式，相当于一种盒子，盒子里面有很多数据

session：

session介绍：session和cookie的作用有点类似，都是为了存储用户相关的信息。不同的是，cookie是存储在本地浏览器，而session存储在服务器。存储在服务器的数据会更加的安全，不容易被窃取。但存储在服务器也有一定的弊端，就是会占用服务器的资源，但现在服务器已经发展至今，一些session信息还是绰绰有余的。
使用session的好处：
- 敏感数据不是直接发送回给浏览器，而是发送回一个session_id，服务器将session_id和敏感数据做一个映射存储在session(在服务器上面)中，更加安全。
- session可以设置过期时间，也从另外一方面，保证了用户的账号安全。
  注意：cookie和session是共同存在的
  下图为一般session的工作机制但flask中的session与其稍有不同

31flask中的session工作机制：

flask中的session机制是：把敏感数据经过加密后放入session中，然后再把session存放到cookie中，下次请求的时候，再从浏览器发送过来的cookie中读取session，然后再从session中读取敏感数据，并进行解密，获取最终的用户数据。
flask的这种session机制，可以节省服务器的开销，因为把所有的信息都存储到了客户端（浏览器）。
安全是相对的，把session放到cookie中，经过加密，也是比较安全的，这点大家放心使用就可以了。
顺序1用户密码 2session 3cookie返回给浏览器

32操作session：

session的操作方式：
- 使用session需要从flask中导入session，以后所有和sessoin相关的操作都是通过这个变量来的。from flask import session
- 使用session需要设置SECRET_KEY，用来作为加密用的。并且这个SECRET_KEY如果每次服务器启动后都变化的话，那么之前的session就不能再通过当前这个SECRET_KEY进行解密了。（因为每次重启服务器24位字符是随机的每次都不同所以可以把 SECRET_KEY写死而不是每次都随机产生）
  SECRET_KEY是24个字符的字符串在config.py设置。如果不想在config.py内设置，也可以直接在app.py内设置。app.config['SECRET_KEY']=os.urandom(24)
- 操作session的时候，跟操作字典是一样的。
- 添加session：session['username']。
- 删除：session.pop('username')或者del session['username']。
- 清除所有session：session.clear()
- 获取session：session.get('username')

下图验证了session放在cookie中且经过了加密
在这里插入图片描述

33设置session的过期时间：

如果没有指定session的过期时间，那么默认是浏览器关闭后就自动结束
如果设置了session的permanent属性为True，那么过期时间是31天。session.permanent=True

相当于用户选择记住我的时候，让这个 session.permanent=True
可以通过给app.config设置PERMANENT_SESSION_LIFETIME来更改过期时间，这个值的数据类型是datetime.timedelay类型。

或者直接写在app.py中：
from datetime import timedelta
app.config['PERMANENT_SESSION_LIFETIME']=timedelta(days=7)#7天后才结束session

34get请求和post请求：

get请求：
- 使用场景：如果只对服务器获取数据，并没有对服务器产生任何影响，那么这时候使用get请求。
- 传参：get请求传参是放在url中，并且是通过?的形式来指定key和value的。
post请求：
- 使用场景：如果要对服务器产生影响，那么使用post请求。
- 传参：post请求传参不是放在url中，是通过form data的形式发送给服务器的。比如登录页面，输入账号和密码之后需要将数据传给session然后保存，session在服务器上面，对服务器产生影响

如图,q为查询的关键字，反转回来的url为：/search/?q=hello 在这里插入图片描述

request.args可以获取传进来的所有参数
在这里插入图片描述

35get和post请求获取参数：

get请求是通过flask.request.args来获取。request.args.get（‘q’）
post请求是通过flask.request.form来获取。request.form.get（‘q’）
post请求在模板中要注意几点：
- input标签中，要写name来标识这个value的key，方便后台获取。如name='username’等
- 在写form表单的时候，要指定method='post'，并且要指定action='/login/'。（指定action就是要把数据提交到哪个url上面）

示例代码：

    <form action="{{ url_for('login') }}" method="post">
        <table>
            <tbody>
                <tr>
                    <td>用户名：</td>
                    <td><input type="text" placeholder="请输入用户名" name="username"></td>
                </tr>
                <tr>
                    <td>密码：</td>
                    <td><input type="text" placeholder="请输入密码" name="password"></td>
                </tr>
                <tr>
                    <td></td>
                    <td><input type="submit" value="登录"></td>
                </tr>
            </tbody>
        </table>
    </form>

36保存全局变量的g属性：

g：global

g对象是专门用来保存用户的数据的。
g对象在一次请求中的所有的代码的地方，都是可以使用的。
from flask import Flask

以下证明g是个全局变量在login_log中也可以使用
在这里插入图片描述

简单模拟：
在这里插入图片描述

注意：g对象在一次请求中的所有的代码的地方可以使用，是一次如果再次请求g是不存在的，会重新创建一份g，如下图当浏览器把用户名和密码传给服务器时候，这时候g和username绑定为zhiliaoketang，当服务器传回给浏览器的时候g就消失了，当浏览器再次请求服务器的时候g会被重新创建在这里插入图片描述

37钩子函数（hook）：

正常是执行函数是AB 有了钩子函数C 变ACB
在这里插入图片描述

before_request：
- 在请求之前执行的
- 是在视图函数执行之前执行的
- 这个函数只是一个装饰器，他可以把需要设置为钩子函数的代码放到视图函数执行之前来执行
  
  可以看出before_request 在视图函数之前执行，本来应该是顺序执行，现在有before_request 这个钩子函数
  就变成hello_world->before_request ->login

在这里插入图片描述
如果session可以获取username 则返回修改成功如果把session删除就返回login

在每次执行视图函数之前都用钩子函数把这些查询工作做完就不用在视图函数里查找这样就节省性能

context_processor：
- 上下文处理器应该返回一个字典。字典中的key会被模板中当成变量来渲染。
- 上下文处理器中返回的字典，在所有页面中都是可用的。如下图上下文处理器返回的‘username’在所有html中都可以使用这个参数{{username}} 但是可以不必再html中写出
- 被这个装饰器修饰的钩子函数，必须要返回一个字典，即使为空也要返回。

index.html处没有穿username的参数但是因为有context_processor也有了username这个参数

38装饰器

在这里插入图片描述

实战1项目构架

cd  D:\PycharmProjects\flaskProject
d:
cd venv
cd Scripts
activate
cd..
cd..
python manage.py  runserver

1创建一个flask项目
2建立config.py
同时在app.py中要有

import config
app.config.from_object

在这里插入图片描述
3连接mysql create database t_demo charset utf8; 创建数据表
4建立exts 存放db

5存放models建立models.py from exts import db
6构建manage.py 存放在终端显示的脚本

from flask_script import Manager
from flask_migrate import Migrate,MigrateCommand
from app import app
from exts import db
from models import User


manager = Manager(app)

# 使用Migrate绑定app和db
migrate = Migrate(app,db)

# 添加迁移脚本的命令到manager中
manager.add_command('db',MigrateCommand)



if __name__ == "__main__":
    manager.run()

2导航条完成

bootstrap：网站www.bootcss.com

在这里插入图片描述导入加速服务一般就引入css和js 复制官网的即可
但是引入js前面添加 juery

<script src="https://cdn.bootcss.com/jquery/3.2.1/jquery.min.js"></script>

在这里插入图片描述

<!-- 最新版本的 Bootstrap 核心 CSS 文件 -->
<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap@3.3.7/dist/css/bootstrap.min.css" integrity="sha384-BVYiiSIFeK1dGmJRAkycuHAHRg32OmUcww7on3RYdg4Va+PmSTsz/K68vbdEjh4u" crossorigin="anonymous">

<!-- 可选的 Bootstrap 主题文件（一般不用引入） -->
<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap@3.3.7/dist/css/bootstrap-theme.min.css" integrity="sha384-rHyoN1iRsVXV4nD0JutlnGaslCJuC7uwjduW9SVrLvRYooPp2bWYgmgJQIXwl/Sp" crossorigin="anonymous">

<!-- 最新的 Bootstrap 核心 JavaScript 文件 -->
 
<script src="https://cdn.jsdelivr.net/npm/bootstrap@3.3.7/dist/js/bootstrap.min.js" integrity="sha384-Tc5IQib027qvyjSMfHjOMaLkfuWVxZxUPnCJA7l2mCWNIpG9mGCD8wGNIcPD7Txa" crossorigin="anonymous"></script>

在body内复制导航条的模板
在static下面建立images和css文件夹
css用来调节各种html中的样式字体等等
在这里插入图片描述
且要引入link css文件

index.css如下在这里插入图片描述

会使得导航条的左右两边会留一些空隙

3父模板分离

base.html
同时也要建立base.css
在这里插入图片描述

4登录页面

在login.html

<li><a href="{{ url_for('login') }}">登录</a></li>

且在base.css中加入样式

.logo{
    width: 50px;
}

body{
    background: #f3f3f3;
}

.main{
    background: #fff;
    width: 730px;
    margin: 0 auto;
    overflow: hidden;
    padding: 10px;#上下添加边距
}

在login-regist .html加样式
选择一个登陆的输入框，表单

<form action="" method="POST">#action默认当前页面
        <div class="form-container">
            <div class="form-group">
                

                <input type="text" class="form-control" placeholder="手机号码" name="telephone">
            </div>
            <div class="form-group">
                <input type="password" class="form-control" placeholder="密码" name="password">
            </div>
            <div class="form-group">
                <button class="btn btn-primary btn-block">登录</button>
            </div>

#app.py
@app.route('/login/',method=['GET','POST'])
def login():
    if request.method=='GET':
        return render_template('login.html')
    else:
        telephone=request.form.get('telephone')
        password=request.form.get('password')
        user=User.query.filter(User.telephone==telephone,User.password==password).first()
        if user:
            session['user_id']=user.id
            session.permanent=True
            return redirect(url_for('index'))
        else
            return u'手机或密码错误请确认后再登录'

5注册页面

regist.html

{% block head %}#控制这些边框的样式
    <link rel="stylesheet" href="{{ url_for('static',filename='css/login_regist.css') }}">
{% endblock %}

{% block main %}
    <h3 class="page-title">注册</h3>
    <form action="" method="POST">
        <div class="form-container">
            <div class="form-group">
                <input type="text" class="form-control" placeholder="手机号码" name="telephone">
            </div>
            {{ msg3 }}
            <div class="form-group">
                <input type="text" class="form-control" placeholder="用户名" name="username">
            </div>
            <div class="form-group">
                <input type="password" class="form-control" placeholder="密码" name="password1">
            </div>
            <div class="form-group">
                <input type="password" class="form-control" placeholder="确认密码" name="password2">
            </div>
            {{ msg4 }}

            <div class="form-group">
                <input type="text" class="col-sm-6" style="height: 33.9px" placeholder="验证码" name="captcha">
            </div>
            <div class="form-group ">
               <img src="{{ url_for('pic') }}" alt="图形验证码" class="col-sm-6" style="height: 33.9px" id="pic"> {#onclick="this.src='/pic/?ran='+ Math.random()"#}
              {{ msg1 }}
            </div>

            <div class="form-group">
                <button class="btn btn-primary btn-block">立即注册</button>
            </div>
        </div>
    </form>

6user模型建立

在models.py中创建

class User(db.Model):
    __tablename__='user'
    id==db.Column(db.Integer,primary_key=True,autoincrement=True)
    telephone=db.Column(db.String(11),nullable=False)
    username=db.Column(db.String(50),nullable=False)
    password=db.Column(db.String(100),nullable=False)

且要在manage.py 把模型导入

from models import User

进入venv /scripts/activate 虚拟环境激活
然后cd…返回到flaskproject python manage.py db.init python manage.py db.migrate python manage.py db.upgrade

MYSQL

 use zlqt_demo
 show tables;
 decs user;
 select * from  user;//显示所有数据

在这里插入图片描述

7注册功能

当到达regist这个视图函数的时候说明已经点击了注册的按钮且获得了用户名密码手机号等等信息
注意在app.py中导入

from models import User 
from exts import db
db.init_app(app)  #记得初始化db

@app.route('/regist/',method=['GET','POST'])
def regist():
    if request.method=='GET':
        return render_template('regist.html')
    else:
        telephone=request.form.get('telephone')
        username=request.form.get('username')
        password1=request.form.get('password1')
        password2=request.form.get('password2')
        
      #如果手机号码被注册了  就不能再注册
      user=User.query.filter(User.telephone==telephone).first()
        if user:
            return u'该号码已被注册，请重新输入'
        else
            #手机号码是没被注册过 验证密码1 2是否同
            if password1!=password2:
                return u'两次密码不相同，请重新输入'
	       else：#号码 密码均符合将user添加到数据库中
	            user=User(telephone=telephone,username=username,password=password1)
	            db.session.add(user)
	            db.session.commit()
	            #注册成功跳转到登录页面
	            return redirect(url_for('login'))

8登录功能

要记得在login.html的input的标签里写上 name=‘xxx’
在这里插入图片描述

@app.route('/login/',method=['GET','POST'])
def login():
    if request.method=='GET':
        return render_template('login.html')
    else:
        telephone=request.form.get('telephone')
        password=request.form.get('password')
        user=User.query.filter(User.telephone==telephone,User.password==password).first()
        if user:
            #把用户相关信息保存在cookie
            session['user_id']=user.id
            session.permanent=True#31天内都不登录
            return redirect(url_for('index'))
        else
            return u'手机或密码错误请确认后再登录'

9注销功能

因为登录后页面右上角会显示 欢迎您xxx ，在所有页面里有会用到，所以就要用上下文处理器 context_processor
注意！要判断用户是否已经登录所以用session[‘user_id’]来判断如果存在则表示之前已经登录过session缓存里面才会有但是用session.get('user_id')来获取其如果不存在会返回null,不存在会返回null,而用session['user_id']如果不存在会抛出异常

@app.context_processor
def my_context_processor():
    user_id=session.get('user_id') #session存在id 说明已经登录 则去找获取这个user的信息
    if user_id:
       user=User.query.filter(User.id=user.id).first()
       if user:
         return {'user':user}
    return {}#即使用户不是在登录状态也要返回一个空的字典 不能不返回

登录了显示 欢迎您xxx和注销
没登录显示 登录注册
在这里插入图片描述

 <ul class="nav navbar-nav navbar-right">
              {% if user %}
                  <li><a href="{{ url_for('center') }}">欢迎您,{{ user.username }}</a></li>
                  <li><a href="{{ url_for('logout') }}">注销</a></li>
              {% else %}
                  <li><a href="{{ url_for('login') }}">登录</a></li>
                  <li><a href="{{ url_for('regist') }}">注册</a></li>
              {% endif %}
          </ul>

注销功能：退出登录即session中的这个user_id删除

@app.route('/logout/')
  def logout():
     sesssion.clear()
    #  sesssion.pop('user_id')
    # del sesssion('user_id')
    #注销后就跳转到登录页面
    return redirect(url_for('login'))

11发布问答

现在app.py中把question这个视图函数写好

@app.route('/question/',methods=['POST','GET'])
def question():
    if request.method=='GET':
        return render_template('')
    else:
       pass

然后写question.html

<form action="",method="post"></form>
        <div class="form-container">//form-container外面那个大盒子
            <div class="form-group">//form-group每个长条都是垂直距离

            </div>
        </div>

在这里插入图片描述

12装饰器详解

如果没有登录时直接按发布问答不可以需要跳转到登录页面登录以后才可以发布

完成这一操作需要先了解装饰器
在这里插入图片描述如上图直接打印hello world可以但是如果有成百上千个函数就很麻烦所以我们定义一个装饰器（就是函数）
装饰器有两个特别之处：（函数进函数出）
1参数是个函数
2返回值是个函数

注意
return wrapper 只是返回wrapper这个函数体不执行
return wrapper（）是返回函数执行结束后的结果
以下为实现每个函数前面都执行打印hello world的功能函数my_log(;func) //参数是个函数返回也是函数wrapper

在这里插入图片描述

def my_log(func):
  def wrapper():
     print 'hello world'
     func()
  return wrapper


@my_log
def run():
   print'run'

run=my_log(run) 

//定义my_log函数后 ，@my_log装饰器写在函数run前面与 run=my_log(run)等价

my_log返回是wrapper 所以run实际上就是wrapper



run()等价于wrapper（）

wrapper（）打印的是hello world且有一个func() 
func()其实就是run本身
打印run

以上就实现了在每个函数前面都先打印hello world

在这里插入图片描述

会报错因为wrapper没有参数但是add是有两个参数的但是wrapper和add又是等价的

但是run（）没有参数 add（）又需要参数所以可能出现需要或不需要参数所以用*args **kwargs他们包含了任何参数
如下所以这样不管带不带参数都可以解决
在这里插入图片描述
run.__name__表示的是run这个函数的名称

在这里插入图片描述

有了装饰器后打印run.__name__应该结果是run但是结果是wrapper 函数名字被改变了

因为放了装饰器后因为run=my_log(run)=wrapper 所以run()与wrapper()等价

为了不改函数名run的结果方法：
再加一个装饰器@wraps()

from functools import wraps
def my_log(func):
  @wraps(func)
  def wrapper(*args,**kwargs):
     print 'hello world'
     func(*args,**kwargs)
  return wrapper


@my_log
def run():
   print'run'

run=my_log(run)

在这里插入图片描述

#登录限制的装饰器
def login_required(func):
    @wraps(func)
    def wrapper(*args,**kwargs):
        if session.get('user_id'):#如果用户登录了
            return func(*args,**kwargs)#返回的是某个页面 记得func前面要加return 不然会产生return render_template('center.html')这样类似的功能
        else:
            return redirect(url_for('login'))
    return wrapper

question前面要加装饰器@login_required 使得没有登录的时候不能发布问答必须跳转到登录页面在这里插入图片描述

13发布问答功能

要保存文章的标题内容所以要建立一张表即模型

class Questio(db.Model):
    __tablename__ = 'question'
    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    title = db.Column(db.String(100), nullable=False)
    content = db.Column(db.Text, nullable=False)
    #now()是第一次服务器运行的时间 以后也是这个
    #now就是每次创建一个模型的时候，都获取当前的时间
    create_time=db.Column(db.DateTime,default=datetime.now)
    author_id=db.Column(db.Integer,db.ForeignKey('user.id'))
    
    author=db.relationship('User',backref=('question'))

要记得映射到数据库中 manage.py from models import User,Question
然后在cmd中迁移数据

cd  D:\PycharmProjects\flaskProject
d:
cd venv
cd Scripts
activate
cd..
cd..
python manage.py  runserver
python manage.py  db migrate
python manage.py  db upgrade

在这里插入图片描述
MYSQL中查看

 use zlqt_demo
 show tables;
 desc question;
 select * from  question;//显示所有数据

在这里插入图片描述

完成question的视图函数

@app.route('/question/',methods=['POST','GET'])
@login_required
def question():
    if request.method=='GET':
        return render_template('question.html')
    else:
        title=request.form.get('title')
        content=request.form.get('content')
        question=Question(title=title,content=content)#添加这个模型
        #取外键
        user_id=session.get('user_id')
        user=User.query.filter(User.id==user_id).first()#把这个user从模型中取出
        question.author=user
        db.session.add(question)
        db.session.commit()
        #发布问答后马上跳转到首页 可以看到自己的回答
        return redirect(url_for('text'))

14社区内容的布局

#视图函数
@app.route('/text/')
def text():
    context={
        'questions':Question.query.all()#所有数据取出 加负号按照时间从大到小排序 order_by(text("-create_time"))


    }
    return render_template('text.html',**context)  # 传参

text.html
{% extends 'base.html' %}

{% block title %}首页{% endblock %}

{% block head %}
    <link rel="stylesheet" href="{{ url_for('static',filename='css/index.css') }}">
{% endblock %}

{% block main %}
    <ul class="question-list-group">
        {% for question in questions %}
            <li>
                <div class="avatar-group">
                    <img src="{{ url_for('static',filename='images/logo.png') }}" alt="" class="avatar">
                </div>
                <div class="question-group">
                    <p class="question-title"><a href="#">{{ question.title }}</a></p>
                    <p class="question-content">{{ question.content }}</p>
                    <div class="question-info">
                        <span class="question-author">{{ question.author.username }}</span>
                        <span class="question-time">{{ question.create_time }}</span>
                    </div>
                </div>
            </li>
        {% endfor %}


    </ul>
{% endblock %}

15问答详情设置
当点击标题的链接时候跳到问答的一个详情页面detail.html

{% extends 'base.html' %}

{% block title %}详情-{% endblock %}

{% block head %}
    <link rel="stylesheet" href="{{ url_for('static',filename='css/detail.css') }}">
{% endblock %}

{% block main %}
    <h3 class="page-title">{{ question.title }}</h3>
    <p class="question-info">
        <span>作者：{{ question.author.username }}</span>
        <span>时间：{{ question.create_time }}</span>
    </p>
    <hr>//hr表示横线
    <p class="question-content">{{ question.content }}</p>
    <hr>
    
{% endblock %}

16评论模块

需要建立一个评论的url 且要处于登录状态

在这里插入图片描述

建立一个添加答案的模型

class Answer(db.Model):
    __tablename__ = 'answer'
    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    content = db.Column(db.Text,nullable=False)
    create_time = db.Column(db.DateTime,default=datetime.now)
    question_id = db.Column(db.Integer,db.ForeignKey('question.id'))
    author_id = db.Column(db.Integer,db.ForeignKey('user.id'))
    # 指定关系 通过Question和User（看作者发表了哪些问答）拿到所有的答案
    question = db.relationship('Question',backref=db.backref('answers',order_by=id.desc()))#且评论按照id序号降序排列
    author = db.relationship('User',backref=db.backref('answers'))

建立模型后要在manage.py引入from models import Answer
然后在cmd中迁移数据

cd  D:\PycharmProjects\flaskProject
d:
cd venv
cd Scripts
activate
cd..
cd..
 
python manage.py  db migrate
python manage.py  db upgrade

```![在这里插入图片描述](https://img-blog.csdnimg.cn/20201214214302949.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3N1ZW9uZw==,size_16,color_FFFFFF,t_70)
*MYSQL中查看* 

```bash
 use zlktqa_demo
 show tables;
 desc answer;
 select * from  answer;//显示所有数据

在这里插入图片描述

{% extends 'base.html' %}

{% block title %}详情-{% endblock %}

{% block head %}
    <link rel="stylesheet" href="{{ url_for('static',filename='css/detail.css') }}">
{% endblock %}

{% block main %}
    <h3 class="page-title">{{ question.title }}</h3>
    <p class="question-info">
        <span>作者：{{ question.author.username }}</span>
        <span>时间：{{ question.create_time }}</span>
    </p>
    <hr>
    <p class="question-content">{{ question.content }}</p>
    <hr>
    <h4>评论：（0）</h4>
    <form action="{{ url_for('add_answer') }}" method="post">
        <div class="form-group">
            <input name="answer_content" type="text" class="form-control" placeholder="请填写评论">
            <input type="hidden" name="question_id" value="{{ question.id }}">#会把input标签内的内容（content和id）传递过去 而且question_id是隐藏的不会被看见的 
        </div>
        <div class="form-group" style="text-align: right;">
            <button class="btn btn-primary">立即评论</button>
        </div>
    </form>
    <ul class="answer-list">
        {% for answer in question.answers %}
            <li>
                <div class="user-info">
                    <img src="{{ url_for('static',filename='images/logo'.png') }}" alt="" class="avatar">
                    <span class="username">{{ answer.author.username }}</span>
                    <span class="create-time">2017-06-30 14:04:54</span>
                </div>
                <p class="answer-content">{{ answer.content }}</p>
            </li>
        {% endfor %}
    </ul>
{% endblock %}

17查找

request.form和request.args.get的区别
1、若get请求改为post请求，那么我们在后台使用request.args访问参数id的值，

使用request.form访问params参数集中各参数的值

例如：

前端代码：1、若get请求改为post请求，那么我们在后台使用request.args访问参数id的值，

使用request.form访问params参数集中各参数的值

例如：

前端代码：
1、若get请求改为post请求，那么我们在后台使用request.args访问参数id的值，

使用request.form访问params参数集中各参数的值

例如：

前端代码：<form method="post">
        <tr>
            昵称<input type="text" style="text-align:center" id="username" name="username" maxlength="8" {% if user_list %} value="{{ user_list.username }}" {% endif %}/>
        </tr>

        <tr>
            真实名字<input type="text" style="text-align:center" id="realname" name="realname" maxlength="20" {% if user_list %} value="{{ user_list.realname }}" {% endif %}/>
        </tr>
        <tr>
            &nbsp
        </tr>

        <tr>
            <button type="submit" id="not_null" style="display: none">确定</button>
            <button type="button" onclick="judge_null()">确定</button>
        </tr>
</form>

def edit_user():
    if request.method == "GET":
        _id = request.args.get('id')
        user_list = json_util.loads(
            json_util.dumps(MongoHelpMaster('temp_users').database.find_one({'_id': ObjectId(_id)})))
        return render_template('temp_site/peom/backend/edit_user.html', user_list=user_list, session=session["info"])
    elif request.method == "POST":
        username = request.form['username']
        realname = request.form['realname']
        _id = request.args.get('id')
        print(_id)
        result = MongoHelpMaster('temp_users').database.update_one({"_id": ObjectId(_id)}, {
            "$set": {'username': username, 'realname': realname}})

当需要获取前端页面表单传过来的id值的时候，我们就需要用request.args.get,而不能用request.form

如果使用request.args，它将提供一个带有GET参数的键值对的dictary

例如：http://website.com/index?arg1=hello&arg2=world

print request.args

{“arg1”: “hello”, “arg2”: “world”}
request.args.get(key)是一个有用的字典函数，如果未设置参数而不是引发一个KeyError，则返回None

备视图函数search() 修改base.html 中搜索输入框所在的

<form action="{{url_for('search') }}" method="get">

<input name="q" type="text"
        placeholder="请输入关键字">

完成视图函数search() 获取搜索关键字 q = request.args.get('q’) 条件查询
qu=Question.query.filter(Question.title.contains(q)).order_by(’-creat_time’)

加载查询结果： return render_template(‘index.html’, question=qu）

组合条件查询 from sqlalchemy import or_, and_

示例：

Lobby.query.filter(

    or_(

        and_(

            Lobby.id == Team.lobby_id,

            LobbyPlayer.team_id == Team.id,

            LobbyPlayer.player_id == player.steamid

        ),

      and_(

            Lobby.id == spectator_table.c.lobby_id,

            spectator_table.c.player_id == player.steamid

        )

    )

)

https://stackoverflow.com/questions/13370993/sqlalchemy-query-and-or-issue

@app.route('/search/')
def search():
    qu=request.args.get('q')
    ques=Question.query.filter(
        or_(
            Question.title.contains(qu),
            Question.detail.contains(qu)
        )
     ).order_by('-create_time')
    return render_template('base.html',questions=ques)
 <form action="{{url_for('search')}}" method="get">
        <input name="q" type="text" placeholder="请输入关键字">
        <button type="submit" >搜索</button>
        </form>

1安装Python2.7：

2Python虚拟环境介绍与安装：

3pip安装flask：

认识url：

4URL详解

5web服务器和应用服务器以及web应用框架：

01Flask基础

6第一个flask程序讲解：

7设置debug模式：

8使用配置文件：

9url传参数：

10反转URL：

11页面跳转和重定向：

02模板笔记

12Flask渲染Jinja2模板和传参：

13if判断：

14for循环遍历列表和字典：

16过滤器：

17继承和block：

18url链接：

19加载静态文件：

20 Mac和Windows下数据库的安装：

21MySQL-python中间件的介绍与安装：

22Flask-SQLAlchemy的介绍与安装：

23Flask-SQLAlchemy的使用：

24使用Flask-SQLAlchemy创建模型与表的映射：

25Flask-SQLAlchemy数据的增、删、改、查：通过session字段

26Flask-SQLAlchemy外键及其关系：

27Flask-Script的介绍与安装：

28分开models以及解决循环引用：

29Flask-Migrate的介绍与安装：

30 cookie和session

cookie：

session：

31flask中的session工作机制：

32操作session：

33设置session的过期时间：

34get请求和post请求：

35get和post请求获取参数：

36保存全局变量的g属性：

37钩子函数（hook）：

38装饰器

实战1项目构架

2导航条完成

3父模板分离

4登录页面

5注册页面

6user模型建立

7注册功能

8登录功能

9注销功能

11发布问答

12装饰器详解

13发布问答功能

14社区内容的布局

16评论模块

17查找

28分开`models`以及解决循环引用：