flaskpython
㈠ 【python基础】flask框架是用来干什么的
你可以用来开发网站服务器,它包含一个wsgi工具包(werkzeug)、 模板引擎(jinja2)还有主体(flask)。
安装方式:
- 打开命令行
- 输入命令
- 命令是"pip install flask"
㈡ Python中Flask框架的变量和函数
可以从模板中直接访问Flask当前的config对象:
就是flask中代表当前请求的request对象:
输出结果为(本机本地运行):
为Flask的session对象
{{ session.get('name') }}
输出结果为(本机本地运行):档蠢
url_for会缓运根据传入的路由器函数名,返回该路由对应的URL,在模板中始终使用url_for()就可以安全的修改路由绑定的URL,则不比担心模板中渲染出错的链接,经常用于超链接,比如下面的例子:
点击即可跳转至主页
同时,如果定义的路由URL是带有参数的,可以把它们作为关键字参数传入url_for(),Flask会把他们填扰蠢梁充进最终生成的URL中:
这个函数会返回之前在flask中通过flask()传入的消息的列表,flash函数可以把由Python字符串表示的消息加入一个消息队列中,再使用get_flashed_message()函数取出它们并消费掉:
㈢ 【Python基础】flask是什么意思
Flask 是一个微框架(Micro framework),其官方文档的前言部分对Flask做了很清楚的定性介绍:
“微”(Micro)是什么意思?
“微”(micro) 并不意味着你要把整个web应用放到一个python文件里(虽然确实可以),也不意味着Flask 在功能上有所欠缺。微框架中的“微”意味着 Flask 旨在保持核心功能的简单而易于扩展。Flask 不会替你做出太多决策,比如使用何种数据库。而那些 Flask 帮你做好的决策(比如使用哪种模板引擎),都是很容易替换。除此之外的一切都由可由你掌握。
默认情况下,Flask 不包含数据库抽象层、表单验证,或是任何已在其它已库中处理的很好的功能。相反,Flask 支持通过扩展来给应用添加这些功能,如同是 Flask 本身实现的一样。众多的扩展提供了数据库集成、表单验证、上传处理及各种各样的开放认证技术等功能。Flask 也许是“微小”的,但它已准备好在复杂的生产环境中投入使用。
Flask尽量避免重复制造轮子,而是与已有的优秀轮子去结合,这使得Flask灵活、强大,且定制性更强。 Flask 配置选项众多,均设置了合理的默认值,并会遵循一些惯例;配置选项均可以修改,但通常没必要修改,尤其是刚开始的时候。这使得Flask易于上手。
㈣ python-flask 快速搭建web
Flask是由python实现的一个web微框架,我们可以使用Python语言快速实现一个网站或Web服务,很方便的实现工具链,或者工作中其他内容的集成展示。
python官网 : https://www.python.org
flask: pip3 install flask
python具有相当多的库可以使用,可以通过 ***pip3 intall xx ***安装各类库,极大的方便快速实现功能。
㈤ python使用Flask框架获取用户IP地址的方法
主要介绍了python使用Flask框架获取用户IP地址的方法,实例分析了Python使用Flask框架remote_addr获取IP的`技巧,非常具有实用价值,需要的朋友可以参考下。
下面的代码包含了html页面和python代码,非常详细,如果你正使用Flask,也可以学习一下最基本的Flask使用方法。
python代码如下:
?
1
2
3
4
5
6
7
8
9
10
11
12
13
from flask import Flask, render_template, request
# Initialize the Flask application
app = Flask(__name__)
# Default route, print user's IP
@app.route('/')
def index():
ip = request.remote_addr
return render_template('index.html', user_ip=ip)
if __name__ == '__main__':
app.run(
host="0.0.0.0",
port=int("80")
)
html代码如下:
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
<!DOCTYPE html>
<html lang="en">
<head>
<link href="bootstrap/3.0.0/css/bootstrap.min.css"
rel="stylesheet">
</head>
<body>
<p class="container">
<p class="header">
<h3 class="text-muted">How To Get The IP Address Of The User</h3>
</p>
<hr/>
<p>
You IP address is: <strong>{{user_ip}}</strong>
<p class="header">
<h3 class="text-muted">Code to retrieve the IP</h3>
</p>
<hr/>
<pre>
from flask import Flask, render_template, request
# Initialize the Flask application
app = Flask(__name__)
# Default route, print user's IP
@app.route('/')
def index():
ip = request.remote_addr
return render_template('index.html', user_ip=ip)
</pre>
</p>
</p>
</body>
</html>
希望本文所述对大家的Python程序设计有所帮助。
㈥ python flask 怎么组织程序
1.初始化
所有的flask程序都必须创建一个程序实例
web服务器使用wsgi接口协议,把接收客户端的请求都转发给这个程序实例来进行处理。这个程序实例就是flask对象
from flask import Flask
app = Flask(__name__)
#__name__决定程序的根目录,以便以后能找到相对于程序根目录的资源文件位置
2.路由和视图函数
程序实例需要知道接收请求后,需要知道url请求应该运行哪些代码。所以保存了一个url和python函数的映射关系;这个映射关系就叫做路由
flask程序中路由的写法:
2.1#使用app.route装饰器,把修饰的函数注册为路由。例如
@app.route('/')def index(): return "<h1>Hello World</h1>"
#函数的名字不是必须写index的,只是和装饰器关联的时候写的函数名而已
#把index函数注册为程序根路径的处理程序。函数的返回值称为响应,是客户端接收的内容。
像index这样的函数称为试图函数,试图函数返回的响应可以是包含html的简单字符串,也可以是复杂的东西
2.2#可变url部分映射,使用特定的装饰器语法就可以
@app.route('/user/<name>')def user(name): return "<h1>hello %s</h1>"%(name)
装饰器中的<name>指定可变内容为name,name对user(name)函数中的传递参数,这2个部分内容必须一致
调用试图函数时候,flask会自动的将动态部分作为参数传入参数,这个函数中,参数用于生成个人的欢迎信息
#备注:路由中的动态部分默认使用字符串类型,可以使用int,float,path来定义;例如<int:id>;path类型也是字符串,但不把斜线视作分隔符,而将其当做动态片段的一部分
3.启动服务器
调用程序实例app的run方法启动flask集成开发的web服务器
if __name__ == "__main__":
app.run(debug=True)
debug=True代表的是调试模式,这个flask自带的run方法开启的服务器不适合在生产中使用,此处只用来测试
4.一个完整的Flask程序
啥也不说,先上例子hello.py
㈦ python web开发用什么框架
对初学者来说,循序渐进是最重要的,我推荐学习 Flask(Welcome | Flask (A Python Microframework))
Flask 很轻,花很少的成本就能够开发一个简单的网站。非常适合初学者学习。
Flask 框架学会以后,可以考虑学习插件的使用。例如使用 WTForm + Flask-WTForm 来验证表单数据,用 sqlAlchemy + Flask-SQLAlchemy 来对你的数据库进行控制。
BTW:果壳网基于 Flask 开发的。
另外也简单介绍下其他框架:
1. Django。如楼上所说,是一个全能型框架。目前 Django 的使用面还是很广的,有学习的价值,但是不建议初学者学习,因为要学习的东西太多了,一下子难以吸收会失去兴趣。当然,Django 的目的是为了让开发者能够 快速 地开发一个网站,它提供了很多模块,其中我最喜欢的就是 admin 模块,http://your.site.com/admin 就进入了网站的后台(内置的哦~)方便地对数据进行操作,等等。。。。因此,如果对 Django 熟悉的话,papapa 一下子就写好一个网站的原型了。
2. Tornado。传说中性能高高的框架。Tornado 是一个很好的框架,支持异步处理的功能,这是它的特点,其他框架不支持。另外一点是,Tornado 的设计似乎更注重 RESTful URL。但 Tornado 提供了网站基本需要使用的模块外,剩下的则需要开发者自己进行扩展。例如数据库操作,虽然内置了一个 database 的模块(后来独立出去了,现在叫做 torndb,bdarnell/torndb · GitHub)但是不支持 ORM,快速开发起来还是挺吃力的。如果需要 ORM 支持的话,还需要自己写一层将 SQLAlchemy 和 Tornado 联系起来,而且这里还有一个坑。
BTW:知乎就是基础 Tornado 开发的。
3. Bottle。Bottle 和 Flask 都属于轻量级的 Web 框架。但是 Bottle 似乎落寞了。我觉得跟他的 API 设计有关系。个人认为 Bottle 使用起来不那么顺手,因此也用得少。这里不做太多介绍。
4. web.py。也是很轻的一个框架,使用不多,也不做介绍。
5. web2py。我看楼上都没有对这个框架做介绍。这个框架是 Google 在 web.py 基础上二次开发而来的,兼容 GAE 。性能据说很高,曾经用他来做自己的主页,感觉也还不错。缺点同样是对扩展支持不太好,需要自己进行扩展。
6. Quixote。着名的 豆瓣 就是基于 Quixote 开发的。跟上面几个框架不同,Quixote 的路由会有些特别。另外 Quixote 的性能据说也好。
㈧ 如何部署简单python + flask应用
我们先写一个最基本的flask应用:
demo.py
from flask import Flask
app = Flask(**name**)
@app.route('\')
def index():
return 'Hello World.'
if __name__ == __main__:
app.run()
运行这个py文件,打开浏览器访问127.0.0.1:5000就能看到显示Hello World的页面 .
如果让这个flask引用监听来自公网ip的请求,理论上你跑此程序的机器就相当于一个服务器了,然而这个服务器并不完美,所以我们需要nginx和gunicorn来增加它的功能,让它真刀真枪上生产环境的时候能按要求运行。
flask自带的WSGI框架性能很差劲,只能适用于开发环境调试使用。我们用专业一点的gunicorn(还有很多其他优秀的框架)替代flask自带的WSGI框架。
配置完后,通过命令’/usr/local/bin/gunicorn -b127.0.0.1:5000‘启动应用。打开浏览器访问127.0.0.1:5000,同样能够得到返回页面
然而gunicorn也仅仅是一个python的WSGI框架而已,要让它真正处理来自互联网的各类访问功能还是有点欠缺,这时候就需要用到大名鼎鼎的nginx 服务器来替gunicorn遮风挡雨了。
Ubuntu下安装nginx可以用命令
sudo apt-get install nginx
安装后需要进行下配置:
cd /etc/nginx/sites-available
sudo vi test (test为配置名称,可以根据自己项目进行命名)
test文件的配置为:
server {
listen 80; # 监听80端口
location / {
proxy_pass http://127.0.0.1:5000; # 代理本机127.0.0.1:5000的服务
}
location /static {
alias /home/ubuntu/myproject/myblog/app/static; # 负载均衡
}
}
cd ..
cd sites-enable
sudo ln -s ../sites-available/lwhile . (创建软链接,别漏掉最后的.)
sudo service nginx reload
sudo service nginx restart
这样nginx的基本配置文件就写好了 接下来我们配置进程管理工具supervisor supervisor可以在后面启动你的python进程,这样很方便
1.cd /etc/supervisor/conf.d
2.sudo vi test.conf (test为文件名)
[program:test]
command = /usr/local/bin/gunicorn -b127.0.0.1:5000 /home/ubuntu/myproject/test.py
3.sudo supervisorctl
4.reload
5.start test
如果一切正常,做完这所有步骤之后,现在公网的ip访问你的主机,就可以打开你的flask应用了
㈨ python中flask如何降低内存
Dict
在小型程序中,特别是在脚本中,使用Python自带的dict来表示结构信息非常简单方便:
>>> ob = {'x':1, 'y':2, 'z':3}
>>> x = ob['x']
>>> ob['y'] = y
由于在Python 3.6中dict的实现采用了一组有序键,因此其结构更为紧凑,更深得人心。但是,让我们看看dict在内容中占用的空间大小:
>>> print(sys.getsizeof(ob))
240
如上所示,dict占用了大量内存,尤其是如果突然虚需要创建大量实例时:
实例数
对象大小
1 000 000
240 Mb
10 000 000
2.40 Gb
100 000 000
24 Gb
类实例
有些人希望将所有东西都封装到类中,他们更喜欢将结构定义为可以通过属性名访问的类:
class Point:
#
def __init__(self, x, y, z):
self.x = x
self.y = y
self.z = z
>>> ob = Point(1,2,3)
>>> x = ob.x
>>> ob.y = y
类实例的结构很有趣:
字段
大小(比特)
PyGC_Head
24
PyObject_HEAD
16
__weakref__
8
__dict__
8
合计:
56
在上表中,__weakref__是该列表的引用,称之为到该对象的弱引用(weak reference);字段__dict__是该类的实例字典的引用,其中包含实例属性的值(注意在64-bit引用平台中占用8字节)。从Python3.3开始,所有类实例的字典的键都存储在共享空间中。这样就减少了内存中实例的大小:
>>> print(sys.getsizeof(ob), sys.getsizeof(ob.__dict__))
56 112
因此,大量类实例在内存中占用的空间少于常规字典(dict):
实例数
大小
1 000 000
168 Mb
10 000 000
1.68 Gb
100 000 000
16.8 Gb
不难看出,由于实例的字典很大,所以实例依然占用了大量内存。
带有__slots__的类实例
为了大幅降低内存中类实例的大小,我们可以考虑干掉__dict__和__weakref__。为此,我们可以借助 __slots__:
class Point:
__slots__ = 'x', 'y', 'z'
def __init__(self, x, y, z):
self.x = x
self.y = y
self.z = z
>>> ob = Point(1,2,3)
>>> print(sys.getsizeof(ob))
64
如此一来,内存中的对象就明显变小了:
字段
大小(比特)
PyGC_Head
24
PyObject_HEAD
16
x
8
y
8
z
8
总计:
64
在类的定义中使用了__slots__以后,大量实例占据的内存就明显减少了:
实例数
大小
1 000 000
64 Mb
10 000 000
640 Mb
100 000 000
6.4 Gb
目前,这是降低类实例占用内存的主要方式。
这种方式减少内存的原理为:在内存中,对象的标题后面存储的是对象的引用(即属性值),访问这些属性值可以使用类字典中的特殊描述符:
>>> pprint(Point.__dict__)
mappingproxy(
....................................
'x': ,
'y': ,
'z': })
为了自动化使用__slots__创建类的过程,你可以使用库namedlist(https://pypi.org/project/namedlist)。namedlist.namedlist函数可以创建带有__slots__的类:
>>> Point = namedlist('Point', ('x', 'y', 'z'))
还有一个包attrs(https://pypi.org/project/attrs),无论使用或不使用__slots__都可以利用这个包自动创建类。
元组
Python还有一个自带的元组(tuple)类型,代表不可修改的数据结构。元组是固定的结构或记录,但它不包含字段名称。你可以利用字段索引访问元组的字段。在创建元组实例时,元组的字段会一次性关联到值对象:
>>> ob = (1,2,3)
>>> x = ob[0]
>>> ob[1] = y # ERROR
元组实例非常紧凑:
>>> print(sys.getsizeof(ob))
72
由于内存中的元组还包含字段数,因此需要占据内存的8个字节,多于带有__slots__的类:
字段
大小(字节)
PyGC_Head
24
PyObject_HEAD
16
ob_size
8
[0]
8
[1]
8
[2]
8
总计:
72
命名元组
由于元组的使用非常广泛,所以终有一天你需要通过名称访问元组。为了满足这种需求,你可以使用模块collections.namedtuple。
namedtuple函数可以自动生成这种类:
>>> Point = namedtuple('Point', ('x', 'y', 'z'))
如上代码创建了元组的子类,其中还定义了通过名称访问字段的描述符。对于上述示例,访问方式如下:
class Point(tuple):
#
@property
def _get_x(self):
return self[0]
@property
def _get_y(self):
return self[1]
@property
def _get_z(self):
return self[2]
#
def __new__(cls, x, y, z):
return tuple.__new__(cls, (x, y, z))
这种类所有的实例所占用的内存与元组完全相同。但大量的实例占用的内存也会稍稍多一些:
实例数
大小
1 000 000
72 Mb
10 000 000
720 Mb
100 000 000
7.2 Gb
记录类:不带循环GC的可变更命名元组
由于元组及其相应的命名元组类能够生成不可修改的对象,因此类似于ob.x的对象值不能再被赋予其他值,所以有时还需要可修改的命名元组。由于Python没有相当于元组且支持赋值的内置类型,因此人们想了许多办法。在这里我们讨论一下记录类(recordclass,https://pypi.org/project/recordclass),它在StackoverFlow上广受好评(https://stackoverflow.com/questions/29290359/existence-of-mutable-named-tuple-in)。
此外,它还可以将对象占用的内存量减少到与元组对象差不多的水平。
recordclass包引入了类型recordclass.mutabletuple,它几乎等价于元组,但它支持赋值。它会创建几乎与namedtuple完全一致的子类,但支持给属性赋新值(而不需要创建新的实例)。recordclass函数与namedtuple函数类似,可以自动创建这些类:
>>>Point = recordclass('Point', ('x', 'y', 'z'))
>>>ob = Point(1, 2, 3)
类实例的结构也类似于tuple,但没有PyGC_Head:
字段
大小(字节)
PyObject_HEAD
16
ob_size
8
x
8
y
8
z
8
总计:
48
在默认情况下,recordclass函数会创建一个类,该类不参与垃圾回收机制。一般来说,namedtuple和recordclass都可以生成表示记录或简单数据结构(即非递归结构)的类。在Python中正确使用这二者不会造成循环引用。因此,recordclass生成的类实例默认情况下不包含PyGC_Head片段(这个片段是支持循环垃圾回收机制的必需字段,或者更准确地说,在创建类的PyTypeObject结构中,flags字段默认情况下不会设置Py_TPFLAGS_HAVE_GC标志)。
大量实例占用的内存量要小于带有__slots__的类实例:
实例数
大小
1 000 000
48 Mb10 000 000
480 Mb
100 000 000
4.8 Gb
dataobject
recordclass库提出的另一个解决方案的基本想法为:内存结构采用与带__slots__的类实例同样的结构,但不参与循环垃圾回收机制。这种类可以通过recordclass.make_dataclass函数生成:
>>> Point = make_dataclass('Point', ('x', 'y', 'z'))
这种方式创建的类默认会生成可修改的实例。
另一种方法是从recordclass.dataobject继承:
class Point(dataobject):
x:int
y:int
z:int
这种方法创建的类实例不会参与循环垃圾回收机制。内存中实例的结构与带有__slots__的类相同,但没有PyGC_Head:
字段
大小(字节)
PyObject_HEAD
16
ob_size
8
x
8
y
8
z
8
总计:
48
>>> ob = Point(1,2,3)
>>> print(sys.getsizeof(ob))
40
如果想访问字段,则需要使用特殊的描述符来表示从对象开头算起的偏移量,其位置位于类字典内:
mappingproxy({'__new__': ,
.......................................
'x': ,
'y': ,
'z': })
大量实例占用的内存量在CPython实现中是最小的:
实例数
大小
1 000 000
40 Mb
10 000 000
400 Mb
100 000 000
4.0 Gb
Cython
还有一个基于Cython(https://cython.org/)的方案。该方案的优点是字段可以使用C语言的原子类型。访问字段的描述符可以通过纯Python创建。例如:
cdef class Python:
cdef public int x, y, z
def __init__(self, x, y, z):
self.x = x
self.y = y
self.z = z
本例中实例占用的内存更小:
>>> ob = Point(1,2,3)
>>> print(sys.getsizeof(ob))
32
内存结构如下:
字段
大小(字节)
㈩ python 生成flask结构 常用
import os
config="""
import os
basedir = os.path.abspath(os.path.dirname( file ))
class Config:
SECRET_KEY ='hard to guess string'
SQLALCHEMY_COMMIT_ON_TEARDOWN = True
FLASKY_MAIL_SUBJECT_PREFIX = '[Flasktest]'
FLASKY_MAIL_SENDER = ' [email protected] '
FLASKY_ADMIN = 'huangat'
@staticmethod
def init_app(app):
pass
class DevelopmentConfig(Config):
DEBUG = True
MAIL_SERVER = 'mail.163.com'
MAIL_PORT = 587
MAIL_USE_TLS = True
MAIL_USERNAME = os.environ.get(')
MAIL_PASSWORD = os.environ.get('MAIL_PASSWORD')
SQLALCHEMY_DATABASE_URI = 'sqlite:///' + os.path.join(basedir, 'data-dev.sqlite')
class TestingConfig(Config):
TESTING = True
SQLALCHEMY_DATABASE_URI = 'sqlite:///' + os.path.join(basedir, 'data-test.sqlite')
class ProctionConfig(Config):
SQLALCHEMY_DATABASE_URI = 'sqlite:///' + os.path.join(basedir, 'data.sqlite')
config = {
'development': DevelopmentConfig,
'testing': TestingConfig,
'proction': ProctionConfig,
'default': DevelopmentConfig
}
"""
manage="""
import os
from app import create_app, db
from app.models import User, Role
from flask_script import Manager, Shell
from flask_migrate import Migrate, MigrateCommand
app = create_app('default')
manager = Manager(app)
migrate = Migrate(app, db)
def make_shell_context():
return dict(app=app, db=db, User=User, Role=Role)
manager.add_command("shell", Shell(make_context=make_shell_context))
manager.add_command('db', MigrateCommand)
if name == ' main ':
manager.run()
"""
models="""
class User:
pass
class Role:
pass
"""
email="""
from threading import Thread
from email import charset
from flask_mail import Message
from flask import render_template
from flask import current_app # 这样就不用使用from manager import app
from . import mail
charset.add_charset('utf-8', charset.SHORTEST, charset.BASE64, 'utf-8')
def send_async_mail(app, msg):
with app.app_context():
mail.send(msg)
def send_mail(receiver, subject, template, **kw):
app = current_app._get_current_object()
msg = Message(subject=subject, sender=app.config[
'FLASKY_MAIL_SENDER'], recipients=[receiver], charset='utf-8')
msg.body = render_template(template + '.txt', **kw)
msg.html = render_template(template + '.html', **kw)
thr = Thread(target=send_async_mail, args=[app, msg])
thr.start()
return thr
"""
init="""
from os import path
from flask import Flask, request
from flask_bootstrap import Bootstrap
from flask_sqlalchemy import SQLAlchemy
from flask_login import LoginManager
from flask_mail import Mail
from flask_moment import Moment
from werkzeug.routing import BaseConverter
from config import config
class RegexConverter(BaseConverter):
bootstrap = Bootstrap()
db = SQLAlchemy()
login_manager = LoginManager()
mail = Mail()
moment = Moment()
login_manager.session_protection = 'strong'
login_manager.login_view = 'auth.login' # login_view设置登陆页面的端点
basedir = path.abspath(path.dirname( file ))
def create_app(config_name):
app = Flask( name )
app.config.from_object(config[config_name])
config[config_name].init_app(app)
"""
maininit="""
from flask import Blueprint
main = Blueprint('main', name )
from . import views, errors
"""
errors="""
from flask import render_template
from . import main
@main.app_errorhandler(404)
def page_not_found(e):
return render_template(駬.html'), 404
@main.app_errorhandler(500)
def internal_server_error(e):
return render_template(驌.html'), 500
"""
forms="""
class NameForm:
pass
"""
views="""
from datetime import datetime
from flask import render_template, session, redirect, url_for
from . import main
from .forms import NameForm
from .. import db
from ..models import User
@main.route('/', methods=['GET', 'POST'])
def index():
form = NameForm()
if form.validate_on_submit():
# ...
return redirect(url_for('main.index'))
return render_template('index.html',form=form, name=session.get('name'),known=session.get('known', False),current_time=datetime.utcnow())
"""
def main():
os.mkdir("app")
os.mkdir("appmain")
os.mkdir("appstatic")
os.mkdir("app emplates")
os.mknod("app emplates404.html")
os.mknod("app emplates500.html")
os.mknod("app emplatesindex.html")
os.mkdir("tests")
os.mkdir("venv")
os.mkdir("migrations")
os.mknod("requirements.txt")
os.mknod("tests_ init .py")
with open("config.py","w") as f:
f.write(config)
with open("manage.py","w") as f:
f.write(manage)
with open("appmodels.py","w") as f:
f.write(models)
with open("appemail.py","w") as f:
f.write(email)
with open("app_ init .py","w") as f:
f.write(init)
with open("appmain_ init _.py","w") as f:
f.write(maininit)
with open("appmainerrors.py","w") as f:
f.write(errors)
with open("appmainforms.py","w") as f:
f.write(forms)
with open("appmainviews.py","w") as f:
f.write(views)
main()