flask之创建项目
一：安装flask
workon flask_project 进入虚拟后安装flask
pip install flask==0.10.1 安装指定的版本
进入虚拟环境的目录，查看创建的所有的虚拟环境，创建的虚拟环境中有指定的python解释器
进入虚拟环境，查看包的管理
总结：虚拟环境与真实环境怎么进行隔离：1.python解释器的隔离 2.包管理的隔离
二：项目迁移
加入项目迁移到别的机器上，那么项目运行所依赖的包，就要到新机器上重亲一个一个重新安装，比较麻烦，经pip的包名生成文件，方便迁移
pip freeze > requirements.txt
三：pycharm创建创建一个桌面目录，项目解释器选择flask_project虚拟环境里面的python3。
1.工程文件下，创建一个hello.py文件
hello.py
from flask import Flask # 创建flask的应用对象 app = Flask(__name__) # 这样设定，就是可以让这个包被别人导入后，__name__== hello.py，判断条件下不满足，因此一般作为程序的入口。 if __name__ == "__main__": pass
2.创建静态文件和模板文件夹：
静态文件夹:static
模板文件夹:templates
3.定义视图函数
hello.py
from flask import Flask # 从flask包中导入一个Flaks类 app = Flask(__name__) # 创建一个实例对象 __name__是必传的参数 @app.route("/") def index(): """ 定义视图函数 :return: """ return "hello flask" if __name__ == "__main__": app.run()
运行这个hello.py，控制台显示
点击或者浏览器输入网址得到：
四：总结程序运行的基本思路
点击app.route进入看源码：route函数
def route(self, rule, **options): """A decorator that is used to register a view function for a # 用于注册视图函数的装饰器，参数为给定的rule规则。 given URL rule. This does the same thing as :meth:`add_url_rule` but is intended for decorator usage:: @app.route('/') def index(): return 'Hello World' For more information refer to :ref:`url-route-registrations`. :param rule: the URL rule as string # url规则的字符串 :param endpoint: the endpoint for the registered URL rule. Flask itself assumes the name of the view function as endpoint # 注册视图规则的端点，flask中假设视图函数的名字为endpoint :param options: the options to be forwarded to the underlying # 请求方式，get,post,默认是get请求方式 :class:`~werkzeug.routing.Rule` object. A change to Werkzeug is handling of method options. methods is a list of methods this rule should be limited to (`GET`, `POST` etc.). By default a rule just listens for `GET` (and implicitly `HEAD`). Starting with Flask 0.6, `OPTIONS` is implicitly added and handled by the standard request handling. """ def decorator(f): endpoint = options.pop('endpoint', None) self.add_url_rule(rule, endpoint, f, **options) return f return decorator # 返回一个decorate函数的引用
装饰器：用route函数，装饰index函数
def route(self,route,**options): def decorate(f): endpoint = options.pop("endpoint",None) self.add_url_rule(rule, endpoint,f,**options) return f return decorator @route("/") def index(): pass
# 相当于
route = route("/")
route(index)
f是什么东西呢？add_url_rule是什么东西呢？点击进如add_url_rule函数： 解释：f 就是视图函数的引用 route就是："/"
@setupmethod def add_url_rule(self, rule, endpoint=None, view_func=None, **options): """Connects a URL rule. Works exactly like the :meth:`route` decorator. If a view_func is provided it will be registered with the endpoint. Basically this example:: @app.route('/') def index(): pass Is equivalent to the following:: def index(): pass app.add_url_rule('/', 'index', index) If the view_func is not provided you will need to connect the endpoint to a view function like so:: app.view_functions['index'] = index Internally :meth:`route` invokes :meth:`add_url_rule` so if you want to customize the behavior via subclassing you only need to change this method. For more information refer to :ref:`url-route-registrations`. .. versionchanged:: 0.2 `view_func` parameter added. .. versionchanged:: 0.6 `OPTIONS` is added automatically as method. :param rule: the URL rule as string :param endpoint: the endpoint for the registered URL rule. Flask itself assumes the name of the view function as endpoint :param view_func: the function to call when serving a request to the # 视图函数的引用 provided endpoint :param options: the options to be forwarded to the underlying :class:`~werkzeug.routing.Rule` object. A change to Werkzeug is handling of method options. methods is a list of methods this rule should be limited to (`GET`, `POST` etc.). By default a rule just listens for `GET` (and implicitly `HEAD`). Starting with Flask 0.6, `OPTIONS` is implicitly added and handled by the standard request handling. """ if endpoint is None: # 没有指明endpoint,默认的用的是视图函数的名字，怎么实现的呢？ endpoint = _endpoint_from_view_func(view_func) # options['endpoint'] = endpoint methods = options.pop('methods', None) # if the methods are not given and the view_func object knows its # methods we can use that instead. If neither exists, we go with # a tuple of only `GET` as default. if methods is None: methods = getattr(view_func, 'methods', None) or ('GET',) methods = set(methods) # Methods that should always be added required_methods = set(getattr(view_func, 'required_methods', ())) # starting with Flask 0.8 the view_func object can disable and # force-enable the automatic options handling. provide_automatic_options = getattr(view_func, 'provide_automatic_options', None) if provide_automatic_options is None: if 'OPTIONS' not in methods: provide_automatic_options = True required_methods.add('OPTIONS') else: provide_automatic_options = False # Add the required methods now. methods |= required_methods # due to a werkzeug bug we need to make sure that the defaults are # None if they are an empty dictionary. This should not be necessary # with Werkzeug 0.7 options['defaults'] = options.get('defaults') or None rule = self.url_rule_class(rule, methods=methods, **options) rule.provide_automatic_options = provide_automatic_options self.url_map.add(rule) if view_func is not None: old_func = self.view_functions.get(endpoint) if old_func is not None and old_func != view_func: raise AssertionError('View function mapping is overwriting an ' 'existing endpoint function: %s' % endpoint) self.view_functions[endpoint] = view_func
先看setupmethos这个函数，也是一个装饰器
def setupmethod(f): """Wraps a method so that it performs a check in debug mode if the first request was already handled. """ def wrapper_func(self, *args, **kwargs): if self.debug and self._got_first_request: raise AssertionError('A setup function was called after the ' 'first request was handled. This usually indicates a bug ' 'in the application where a module was not imported ' 'and decorators or other functionality was called too late.\n' 'To fix this make sure to import all your view modules, ' 'database models and everything related at a central place ' 'before the application starts serving requests.') return f(self, *args, **kwargs) return update_wrapper(wrapper_func, f)
def add_url_rule(self, rule, endpoint=None, view_func=None, **options):
if endpoint is None: # 没有指明endpoint,默认的用的是视图函数的名字，怎么实现的呢？
endpoint = _endpoint_from_view_func(view_func) #
options['endpoint'] = endpoint
methods = options.pop('methods', None)
provide_automatic_options = getattr(view_func,
'provide_automatic_options', None)
if provide_automatic_options is None:
if 'OPTIONS' not in methods:
provide_automatic_options = True
required_methods.add('OPTIONS')
else:
provide_automatic_options = False
options['defaults'] = options.get('defaults') or None
rule = self.url_rule_class(rule, methods=methods, **options)
rule.provide_automatic_options = provide_automatic_options
self.url_map.add(rule)
if view_func is not None:
old_func = self.view_functions.get(endpoint)
if old_func is not None and old_func != view_func:
raise AssertionError('View function mapping is overwriting an '
'existing endpoint function: %s' % endpoint)
self.view_functions[endpoint] = view_func
# 相当于
setmethod = setmethod(add_url_rule)
setmethod()
化简函数，分析setmethods怎么装饰函数add_url_rule
def setupmethod(f): # f函数其实就是add_url_role函数 def wrapper_func(self, *args, **kwargs): if self.debug and self._got_first_request: raise AssertionError('A setup function was called after the ' 'first request was handled. This usually indicates a bug ' 'in the application where a module was not imported ' 'and decorators or other functionality was called too late.\n' 'To fix this make sure to import all your view modules, ' 'database models and everything related at a central place ' 'before the application starts serving requests.') return f(self, *args, **kwargs) return update_wrapper(wrapper_func, f) # 等价于 return wrapper
setupmethod = settupmethod(add_url_role)
setupmethod() # update_wrapper(wrapper_func,add_url_role)
来看看update_wrapper()函数：
WAPPER_ASSIGNMENTS = ("__module","__name__","__qualname__","__doc__","__annotation__") # 提前定义好的常量
WRAPPER_UPDATES = ("__dict__") # 提前定义好的常量
def update_wrapper(wrapper, wrapper == wrapper_func wrapped, wrapperd == add_url_role assigned = WRAPPER_ASSIGNMENTS, updated = WRAPPER_UPDATES): """Update a wrapper function to look like the wrapped function # wrapper is the function to be updated # 内层函数wrapper_func wrapped is the original function # 原始函数 add_url_role assigned is a tuple naming the attributes assigned directly from the wrapped function to the wrapper function (defaults to functools.WRAPPER_ASSIGNMENTS) updated is a tuple naming the attributes of the wrapper that are updated with the corresponding attribute from the wrapped function (defaults to functools.WRAPPER_UPDATES) """ for attr in assigned: try: value = getattr(wrapped, attr) except AttributeError: pass else: setattr(wrapper, attr, value) for attr in updated: getattr(wrapper, attr).update(getattr(wrapped, attr, {})) # Issue #17482: set __wrapped__ last so we don't inadvertently copy it # from the wrapped function when updating __dict__ wrapper.__wrapped__ = wrapped # Return the wrapper so this can be used as a decorator via partial() return wrapper # 返回值还是内函数的引用，为什么要这么麻烦，多写这么多的代码？
# getattr函数的作用？settattr函数的作用？
def a(): pass def b(): pass WAPPER_ASSIGNMENTS = ("__module","__name__","__qualname__","__doc__","__annotation__") for attr in WAPPER_ASSIGNMENTS: try: value = getattr(a,attr) print("a函数的{}属性值是{}".format(attr,value)) except AttributeError: pass else: setattr(b,attr,value) # 把b函数的__name__的值设置成a的__name__的值 print(b.__name__) # 打印的结果 a函数的__name__属性值是a a函数的__qualname__属性值是a a函数的__doc__属性值是None a
endpoint到底是个啥东西，怎么默认值为None，官方解释确实endpoint默认为视图函数的名字呢？点进_endpoint_from_view_func（view_func）：
def _endpoint_from_view_func(view_func): """Internal helper that returns the default endpoint for a given function. This always is the function name. """ assert view_func is not None, 'expected view func if endpoint ' \ # view_func本来就是None，默认值为None 'is not provided.' return view_func.__name__ # 返回view_func.__name__名称
