zoukankan html css js c++ java

flask 之(五) --- 对象|钩子|拆分

内置对象

request：　　请求的所有信息
session　　服务端会话技术的接口
config:　　当前项目的配置信息，模板中可以直接使用
g：global　　在单次请求过程中，实现全局数据共享(可以帮助开发者实现跨函数传递数据)

from flask import Blueprint, render_template, g
from .models import User

user_blue = Blueprint('user_blue',__name__,url_prefix="/users/")

@user_blue.route('/')
def hello_world():
    return 'User Index!'

@user_blue.route('/create/')
def create():
    # g的信息即使没有被返回渲染，也可以在html中获取到
    g.msg = "g的信息"
    return render_template('index.html')

 1 <!DOCTYPE html>
 2 <html lang="en">
 3 <head>
 4     <meta charset="UTF-8">
 5     <title>Index</title>
 6 </head>
 7 <body> # 获取全局变量的值
 8 <h1>{{ g.msg }}</h1>
 9 </body>
10 </html>

config 或者app

　　config表示当前运行的项目。遍历config时是获取当前运行的App的配置 [配置应该是有价值的]

　　在python代码中current_app.config，当前运行的app。用在函数中，使用记得是在初始化完成之后

1 <body>
2 <ul>
3     {% for foo in config %}
4         <li>{{ foo }}</li>
5     {% endfor %}
6 </ul>
7 </body>

钩子函数

编程模型：

OOP: 面向对象编程；POP: 面向过程编程
AOP:　面向切面编程；IOP:　面向接口编程

面向切面：

　　在不修改原有逻辑代码的基础上。动态的去添加一些功能或者控制逻辑（装饰器类似）

　　动态介入到既有流程中，去监控或者去获取我们想要的数据

　　蓝图和app上都有钩子函数，app上的钩子优先级更高一些；蓝图只能处理本蓝图内容的信息

重要概念：

　　切面：切开后可以获取的东西叫切面。(在flask中叫做钩子函数)

　　　　　请求前切面获取：　　request

　　　　　请求后切面获取：　　request、response

　　　　　请求异常切面获取：　exception、request

　　切点：可切的地方叫切点。请求前、请求后、请求异常

　　　　　请求前切点：　　@user_blue.before_request

　　　　　请求后切点：　　@user_blue.before_request

　　　　　请求异常切点：　@user_blue.errorhandler(500)

 1 """
 2 常用请求钩子：
 3 
 4     before_first_request：     在处理app第一个请求前运行。
 5 
 6     before_request：　　　　    在每次请求前运行。
 7 
 8     after_request：　　　　　   如果处理逻辑没有异常抛出，在每次请求后运行。
 9 
10     teardown_request：　　     在每次请求后运行，即使处理发生了错误。
11 
12     teardown_appcontext：　    在应用上下文从栈中弹出之前运行
13 """

 1 # 定义钩子函数：相当于django中的中间件
 2 
 3 # before_request装饰的方法会加载到app的before_request_funcs列表中，按加载的顺序依次执行，不需要参数
 4 @app.before_request
 5 def test_before_request():
 6     print('before_request：2')
 7 
 8 # before_first_request装饰的函数加载到before_first_request_funcs列表中，只不过在app第一次接收到请求后执行，其他时候不再执行
 9 @app.before_first_request
10 def test_before_first_request():
11     print('before_first_request：1')
12 
13 # after_request装饰的函数加载到after_request_funcs列表中，传入的参数是response对象，可以对其进行拦截修改，必须返回一个response对象
14 @app.after_request
15 def test_after_request(resp):
16     print(resp)
17     print('after_request：3')
18     return resp

 1 @bp.before_request
 2 def test_before_request():
 3     """
 4     每个视图函数执行之前，都会执行此函数
 5     根据业务决定是否有返回值
 6     :return:
 7     """
 8     print('in before request')
 9     g.start_time = time.time()
10 
11     # before_request 可以用在对所有请求的登录认证中
12     # 1、通过session，获取用户id
13     # 2、根据用户id查找用户对象
14     # 3、如果用户id合法，则认为登录合法
15     # 4、在后续的所有视图函数中，可以直接使用 g.user 获得当前登录的user对象
16     # uid = session.get('uid')
17     # user = User.query.get(uid)
18     #
19     # if user:
20     #     g.user = user
21     #     g.is_login = True
22     # else:
23     #     g.user = None
24     #     g.is_login = False
25 
26 
27 
28 @bp.after_request
29 def test_after_request(response):
30     print('in after request')
31     start_time = g.start_time
32     exec_time = time.time() - start_time
33     print('exec_time:', exec_time)
34     return response

钩子和对象

内置蓝图钩子 [请求前]

 1 from flask import Blueprint, render_template, g
 2 from .models import User
 3 
 4 user_blue = Blueprint('user_blue',__name__,url_prefix="/users/")
 5 
 6 @user_blue.route('/')
 7 def hello_world():
 8     return 'User Index!'
 9 
10 @user_blue.route('/create/')
11 def create():
12     
13     print('create视图函数，在钩子函数执行之后执行')
14     
15     # 接收before钩子函数传递过来的数据
16     print("before钩子函数传递过来的数据：",g.data)
17     
18     # g的信息即使没有被返回渲染，也可以在html中获取到
19     g.msg = "g的信息"
20     return render_template('index.html')
21 
22 # 切面 即钩子函数
23 @user_blue.before_request
24 def before():
25     
26     print("before钩子函数，在路由函数执行之前执行")
27     
28     # 向create视图函数中传递数据
29     g.data = "钩子函数 给 视图函数 的数据"

内置蓝图钩子 [请求后]

 1 from flask import Blueprint
 2 from .models import Movie
 3 
 4 movie_blue = Blueprint("movie_blue",__name__,url_prefix="/movies/")
 5 
 6 @movie_blue.route('/')
 7 def index():
 8     return "Movie Index"
 9 
10 @movie_blue.before_request
11 def before():
12     print("before")
13 
14 @movie_blue.after_request
15 def after(resp):　　# 切开时获取到的返回值作为参数
16     print("after")
17     　　　　　　　　　# 切开后，需要把切之前要返回的信息接着返回出去
18     return resp

内置蓝图钩子 [异常捕获]

 1 from flask import Blueprint
 2 from .models import Movie
 3 
 4 movie_blue = Blueprint("movie_blue",__name__,url_prefix="/movies/")
 5 
 6 @movie_blue.route('/')
 7 def index():
 8     return "Movie Index"
 9 # 请求前
10 @movie_blue.before_request
11 def before():
12     print("before")
13 # 请求后
14 @movie_blue.after_request
15 def after(resp):
16     print("after")
17     # 切开后，需要把切之前要返回的信息接着返回出去
18     return resp
19 # 异常捕获
20 @movie_blue.errorhandler(500) 　　# 错误码
21 def error500(exce): 　　　　　　　　# 获取异常参数
22     print(type(exce))
23     return "异常信息屏蔽，返回到首页"

　　可以在项目的目录下新建一个 middleware.py 文件。将切面编程代码编写在middleware文件中。

　　然后在__init__.py文件中把中间件middleware加载进来：load_middleware(app)。改成全局的中间件，优先级更高

　　在middleware.py 文件中，声明一个 load_mindleware(app)函数，导入相应的包，然后在此函数下写中间件视图函数

1 def load_middleware(app):
2 
3     @app.before_request()
4     def before():
5         print("before")

项目拆分

　　在开发过程中多人合作完成，就需要考虑项目的重构性、扩展性。在一个文件中写代码，是非常不理想的。就需要对文件进行拆分。

　　拆分：

　　　　首先有一个文件的程序，名字就叫这个项目的名字。通过flask-script可以将这个文件改变成统筹管理这个项目的文件，

　　　　将此文件名字改成 manage。用它来统筹管理我们这个项目。然后新建一个名为App包文件，用来存放此项目的文件

　　　　在包文件中，通常将创建flask的过程写在 __init__.py 文件中，天然单例首先被调用。

　　　　在setting.py文件中做配置信息，在__init__ 中加载配置文件进来。

　　　　在extension.py文件中做扩展库的信息，在__init__中初始化扩展库。

　　　　在views.py文件中做视图函数信息，在__init__中初始化路由，尽量最后初始化路由（是web的入口，在启动时需要其他信息加载好）

　　　　在model.py文件中操作数据信息，views.py 文件操作 model.py ；model.py 还需要extenson扩展库文件中的db

　　总结：

　　　　配置要优先于初始化。首先初始化配置信息；然后初始化扩展库；最后初始化路由。启动项目的时候从manage.py开始启动

　　　　启动的时候首先创建Flask对象，然后对Flask对象的配置进行各种初始化，加载完初始化后去加载扩展库，最后初始化路由。

　　分析：

　　　　manager.py文件中创建Flask的app实例(对象)。通过App/__init__.py文件中的 create_app 函数来创建Flask的App实例。

　　　　　　并且把创建好的app实例交给Manager来管理

　　　　App/__init__.py文件中加载初始化各种配置：创建app实例、加载配置文件、加载扩展库文件、加载路由(蓝图)。

　　　　　　创建app实例：通过 create_app 函数来创建Flask的app实例(对象)。

　　　　　　加载配置文件：通过 config.from_object(Config) 加载对象的方式加载setting.py中创建的配置类Config对象

　　　　　　加载扩展文件：通过 init_ext(app) 函调用的方式，将app实例以参数的形式传入到扩展文件extension.py文件中的init_ext函数中。

　　　　　　　　　　　　　对app实例进行扩展信息初始化。通过这种方式避免循环导入的问题

　　　　　　加载路由文件：通过 init_blue(app) 函数调用的方式，将app实例以参数的形式传入到视图views.py文件中。在init_blue函数中，对app进行(蓝图)初始化。

　　　　　　　　　　　　　避免循环导入问题的出现

　　坑点：

　　　　在使用views文件中的视图函数创建数据库表的时候，需要将models文件中的表导入到视图文件中。

　　　　即：views.py 文件中导入：from App.models import User。不然无法识别需要创建的该表的信息。

manage.py 文件

 1 """ manage.py """
 2 
 3 import os
 4 from flask_script import Manager
 5 from App import create_app
 6 
 7 # 从系统环境中获取参数FLASK_ENV的值给env,判断是什么环境下的服务器
 8 # 避免外人修改代码，方便代码放在什么环境服务器下，就在什么环境下运行
 9 # 在系统终端 vim .bashrc 编写系统环境变量：#FLASK_ENV。export FLASK_ENV = "develop" 保存退出
10 env = os.environ.get("FLASK_ENV") or 'default'
11 
12 # 首先创建一个flask对象、加载配置、加载扩展库、初始化路由
13 app = create_app(env)
14 # flask-scripy扩展
15 manager = Manager(app)
16 
17 if __name__ == '__main__':
18     manager.run()

__init__.py

 1 ''' __init__.py '''
 2 from flask import Flask
 3 from App.settings import Config, envs
 4 from App.extension import init_ext
 5 from App.views import init_blue
 6 
 7 def create_app(env):
 8 
 9     # 创建Flask对象
10     app = Flask(__name__)
11 
12     # 加载初始化配置。 从类对象中加载。env参数确定在什么环境下的
13     app.config.from_object(envs.get(env))
14 
15     # 加载初始化扩展库。通过懒加载的方式加载(调用函数时参数的传递)
16     init_ext(app)
17 
18     # 加载初始化路由器。通过懒加载的方式加载(调用函数时参数的传递)
19     init_blue(app)
20 
21     return app

settings.py

 1 ''' settings.py '''
 2 
 3 # 对连接数据库的配置信息进行格式化整理
 4 def get_db_uri(dbinfo):
 5     database = dbinfo.get("DATABASE")
 6     driver = dbinfo.get("DRIVER")
 7     user = dbinfo.get("USER")
 8     password = dbinfo.get("PASSWORD")
 9     host = dbinfo.get("HOST")
10     port = dbinfo.get("PORT")
11     name = dbinfo.get("NAME")
12     return "{}+{}://{}:{}@{}:{}/{}".format(database,driver,user,password,host,port,name)
13 
14 
15 # 配置信息初始化
16 class Config:
17     SECRET_KEY = 'asdfghjjkl'  # 随机值。系统可以基于一个密码随机生成随机值，这个值可以用来做密钥：
18     DEBUG = False
19     TESTING = False
20     SQLALCHEMY_TRACK_MODIFICATIONS = False
21 
22 
23 # 开发环境
24 class DevelopConfig(Config):
25     DEBUG = True
26     # 数据库信息配置
27     dbinfo = {
28         "DATABASE": "mysql",
29         "DRIVER":"pymysql",
30         "USER": "root",
31         "PASSWORD": "guoyapeng",
32         "HOST": "localhost",
33         "PORT": "3306",
34         "NAME": "FlaskModel",
35     }
36     SQLALCHEMY_DATABASE_URI = get_db_uri(dbinfo)
37 # 测试环境
38 class TestingConfig(Config):
39     TESTING = True
40     # 数据库信息配置
41     dbinfo = {
42         "DATABASE": "mysql",
43         "DRIVER":"pymysql",
44         "USER": "root",
45         "PASSWORD": "guoyapeng",
46         "HOST": "localhost",
47         "PORT": "3306",
48         "NAME": "FlaskModel",
49     }
50     SQLALCHEMY_DATABASE_URI = get_db_uri(dbinfo)
51 # 演示环境
52 class StagingConfig(Config):
53     # 数据库信息配置
54     dbinfo = {
55         "DATABASE": "mysql",
56         "DRIVER":"pymysql",
57         "USER": "root",
58         "PASSWORD": "guoyapeng",
59         "HOST": "localhost",
60         "PORT": "3306",
61         "NAME": "FlaskProject",
62     }
63     SQLALCHEMY_DATABASE_URI = get_db_uri(dbinfo)
64 # 生产环境
65 class ProductConfig(Config):
66     # 数据库信息配置
67     dbinfo = {
68         "DATABASE": "mysql",
69         "DRIVER":"pymysql",
70         "USER": "root",
71         "PASSWORD": "guoyapeng",
72         "HOST": "localhost",
73         "PORT": "3306",
74         "NAME": "FlaskModel",
75     }
76     SQLALCHEMY_DATABASE_URI = get_db_uri(dbinfo)
77 
78 # 获取在什么环境下，不同环境下数据库不同
79 envs = {
80     "develop":  DevelopConfig,
81     "texting":  TestingConfig,
82     "staging":  StagingConfig,
83     "product":  ProductConfig,
84     "default":  ProductConfig,
85 }

extension.py

 1 ''' extension.py '''
 2 from flask_sqlalchemy import SQLAlchemy
 3 from flask_migrate import Migrate
 4 
 5 db = SQLAlchemy()
 6 migate  = Migrate()
 7 
 8 # 通过写一个函数，使用函数传参数的形式将app传递过来。然后db利用app进行初始化
 9 def init_ext(app):
10     db.init_app(app) # db需要使用传过来的参数app来进行初始化
11     migate.init_app(app,db)

models.py

1 ''' models.py '''
2 from App.extension import db
3 
4 class User(db.Model):
5     id = db.Column(db.Integer,primary_key=True,autoincrement=True)
6     name = db.Column(db.String(32),unique=True)
7     password = db.Column(db.String(32))

views.py

 1 ''' views.py '''
 2 from flask import Blueprint
 3 from App.extension import db
 4 from App.models import User
 5 
 6 blue = Blueprint('blue',__name__)
 7 def init_blue(app):
 8     app.register_blueprint(blueprint=blue)
 9 
10 
11 @blue.route('/')
12 def hello_world():
13     return 'Hello index!'
14 
15 @blue.route('/create/')
16 def create():
17     db.create_all()
18     return '创建成功'

视图拆分

　　选中views.py文件，右击选择Refactor选项，然后选择Convert To Python Package选项。将原来的views.py文件转换成一个包文件。再在这个包文件中去新建需要的view视图文件。

__init.py__

1 from App.views.movie_view import movie_blue
2 from App.views.user_view import user_blue
3 
4 # 蓝图注册初始化
5 def init_blue(app):
6     app.register_blueprint(blueprint=user_blue)
7     app.register_blueprint(blueprint=movie_blue)

user_view.py

 1 from flask import Blueprint
 2 from App.extension import db
 3 from App.models import User
 4 
 5 user_blue = Blueprint('user_blue',__name__,url_prefix="/users/")
 6 
 7 @user_blue.route('/')
 8 def hello_world():
 9     return 'User Index!'
10 
11 @user_blue.route('/create/')
12 def create():
13     db.create_all()
14     return '创建成功'

movie_view.py

1 from flask import Blueprint
2 
3 movie_blue = Blueprint("movie_blue",__name__,url_prefix="/movies/")
4 
5 @movie_blue.route('/')
6 def index():
7     return "Movie Index"

模型拆分

　　选中model.py文件，右击选择Refactor选项，然后选择Convert To Python Package选项。

　　将原来的model.py文件转换成一个包文件。再在这个包文件中去新建需要的model模型文件。

__init.py__

# 将各model文件导入到此文件中，作为对外的统一接口设置。
from .user_model import User
from .movie_model import Movie

user_model.py

1 from App.extension import db
2 
3 class User(db.Model):
4     id = db.Column(db.Integer,primary_key=True,autoincrement=True)
5     name = db.Column(db.String(32),unique=True)
6     password = db.Column(db.String(32))

movie_model.py

1 from App.extension import db
2 
3 class Movie(db.Model):
4     id = db.Column(db.Integer, primary_key=True, autoincrement=True)
5     m_name = db.Column(db.String(32))
6     m_detail = db.Column(db.String(32))

高级拆分方法 [推荐使用]

　　此方法推荐使用。将每一个功能模块拆分一个包文件，然后再在这个包文件中进行路由视图函数、模型的逻辑书写。今后使用直接copy后，根据需求添加修改就可以

　　day05_chaiAdvanced包文件中是此项目的各种配置。以后想加什么功能模块，就在此文件同级目录创建包文件模块，然后在工程目录下的views.py文件中注册上就可以了。

　　第一块是程序的入口，叫做：manage。

　　第二块是和工程名同名的一个包，里面有__init__.py文件、setting.py文件配置信息、extension.py文件负责扩展库、views.py文件负责路由注册

　　　　__init__.py 文件中，有一个创建app设置，在程序入口manage内调用，

　　　　__init__内：根据设置文件setting.py 加载配置；

　　　　　　　　　　根据扩展库文件extension.py 初始化第三方扩展库；

　　　　　　　　　　根据初始化路由文件views.py 进行加载路由

　　第三块是各个子模块。user包文件、movies包文件.........。各个子模块中又都有自己的 views.py文件和models.py文件

manage.py 文件中

 1 """ manage.py """
 2 
 3 import os
 4 
 5 from flask_migrate import MigrateCommand
 6 from flask_script import Manager
 7 from day05_chaiAdvanced import create_app
 8 
 9 # 从系统环境中获取参数FLASK_ENV的值给env,判断是什么环境下的服务器
10 # 避免外人修改代码，方便代码放在什么环境服务器下，就在什么环境下运行
11 # 在系统终端 vim .bashrc 编写系统环境变量：#FLASK_ENV。export FLASK_ENV = "develop" 保存退出
12 env = os.environ.get("FLASK_ENV") or 'default'
13 
14 # 首先创建一个flask对象、加载配置、加载扩展库、初始化路由
15 app = create_app(env)
16 # flask-scripy扩展
17 manager = Manager(app)
18 manager.add_command("db",MigrateCommand)
19 
20 if __name__ == '__main__':
21     manager.run()

day05_chaiAdvanced 包文件中

__init__.py

 1 ''' __init__.py '''
 2 from flask import Flask
 3 from day05_chaiAdvanced.settings import Config, envs
 4 from day05_chaiAdvanced.extension import init_ext
 5 from day05_chaiAdvanced.views import init_blue
 6 
 7 def create_app(env):
 8 
 9     # 创建Flask对象
10     app = Flask(__name__)
11 
12     # 加载初始化配置。 从类对象中加载。env参数确定在什么环境下的
13     app.config.from_object(envs.get(env))
14 
15     # 加载初始化扩展库。通过懒加载的方式加载(调用函数时参数的传递)
16     init_ext(app)
17 
18     # 加载初始化路由器。通过懒加载的方式加载(调用函数时参数的传递)
19     init_blue(app)
20 
21     return app

extension.py

 1 ''' extension.py '''
 2 from flask_sqlalchemy import SQLAlchemy
 3 from flask_migrate import Migrate
 4 
 5 db = SQLAlchemy()
 6 migate  = Migrate()
 7 
 8 # 通过写一个函数，使用函数传参数的形式将app传递过来。然后db利用app进行初始化
 9 def init_ext(app):
10     db.init_app(app) # db需要使用传过来的参数app来进行初始化
11     migate.init_app(app,db)

settings.py

 1 ''' settings.py '''
 2 # 对连接数据库的配置信息进行格式化整理
 3 def get_db_uri(dbinfo):
 4     database = dbinfo.get("DATABASE")
 5     driver = dbinfo.get("DRIVER")
 6     user = dbinfo.get("USER")
 7     password = dbinfo.get("PASSWORD")
 8     host = dbinfo.get("HOST")
 9     port = dbinfo.get("PORT")
10     name = dbinfo.get("NAME")
11     return "{}+{}://{}:{}@{}:{}/{}".format(database,driver,user,password,host,port,name)
12 
13 
14 # 配置信息初始化
15 class Config:
16     SECRET_KEY = 'asdfghjjkl'  # 随机值。系统可以基于一个密码随机生成随机值，这个值可以用来做密钥：
17     DEBUG = False
18     TESTING = False
19     SQLALCHEMY_TRACK_MODIFICATIONS = False
20 
21 
22 # 开发环境
23 class DevelopConfig(Config):
24     DEBUG = True
25     # 数据库信息配置
26     dbinfo = {
27         "DATABASE": "mysql",
28         "DRIVER":"pymysql",
29         "USER": "root",
30         "PASSWORD": "guoyapeng",
31         "HOST": "localhost",
32         "PORT": "3306",
33         "NAME": "FlaskModel",
34     }
35     SQLALCHEMY_DATABASE_URI = get_db_uri(dbinfo)
36 # 测试环境
37 class TestingConfig(Config):
38     TESTING = True
39     # 数据库信息配置
40     dbinfo = {
41         "DATABASE": "mysql",
42         "DRIVER":"pymysql",
43         "USER": "root",
44         "PASSWORD": "guoyapeng",
45         "HOST": "localhost",
46         "PORT": "3306",
47         "NAME": "FlaskModel",
48     }
49     SQLALCHEMY_DATABASE_URI = get_db_uri(dbinfo)
50 # 演示环境
51 class StagingConfig(Config):
52     # 数据库信息配置
53     dbinfo = {
54         "DATABASE": "mysql",
55         "DRIVER":"pymysql",
56         "USER": "root",
57         "PASSWORD": "guoyapeng",
58         "HOST": "localhost",
59         "PORT": "3306",
60         "NAME": "FlaskProject",
61     }
62     SQLALCHEMY_DATABASE_URI = get_db_uri(dbinfo)
63 # 生产环境
64 class ProductConfig(Config):
65     # 数据库信息配置
66     dbinfo = {
67         "DATABASE": "mysql",
68         "DRIVER":"pymysql",
69         "USER": "root",
70         "PASSWORD": "guoyapeng",
71         "HOST": "localhost",
72         "PORT": "3306",
73         "NAME": "FlaskModelAdvanced",
74     }
75     SQLALCHEMY_DATABASE_URI = get_db_uri(dbinfo)
76 
77 # 获取在什么环境下，不同环境下数据库不同
78 envs = {
79     "develop":  DevelopConfig,
80     "texting":  TestingConfig,
81     "staging":  StagingConfig,
82     "product":  ProductConfig,
83     "default":  ProductConfig,
84 }
85 
86 settings.py

settings.py

views.py

1 from movies.views import movie_blue
2 from users.views import user_blue
3 
4 # 创建的模块中的蓝图进行注册初始化
5 def init_blue(app):
6     app.register_blueprint(blueprint=user_blue)
7     app.register_blueprint(blueprint=movie_blue)

movies.py 包文件中

__init__.py 空
models.py

1 from day05_chaiAdvanced.extension import db
2 
3 
4 class Movie(db.Model):
5     id = db.Column(db.Integer, primary_key=True, autoincrement=True)
6     m_name = db.Column(db.String(32))
7     m_detail = db.Column(db.String(32))

views.py

1 from flask import Blueprint
2 from .models import Movie 
3 
4 movie_blue = Blueprint("movie_blue",__name__,url_prefix="/movies/")
5 
6 @movie_blue.route('/')
7 def index():
8     return "Movie Index"

users.py 包文件中和movies.py 包文件类似。为了实现相应的功能的视图和模型的编写

生如逆旅一苇以航

查看全文

相关阅读:
HDU 1075 What Are You Talking About（字典树）
HDU 1075 What Are You Talking About （stl之map映射）
HDU 1247 Hat’s Words（字典树活用）
字典树HihoCoder
HDU 1277全文检索（字典树）
HDU 3294 Girls' research（manachar模板题）
HDU 3294 Girls' research（manachar模板题）
HDU 4763 Theme Section(KMP灵活应用）
Ordering Tasks UVA
Abbott's Revenge UVA

原文地址：https://www.cnblogs.com/TMMM/p/11479517.html