当前位置:首页 » 编程语言 » flaskpython

flaskpython

发布时间: 2023-03-21 21:59:09

㈠ 【python基础】flask框架是用来干什么的

你可以用来开发网站服务器,它包含一个wsgi工具包(werkzeug)、 模板引擎(jinja2)还有主体(flask)。

安装方式:

  1. 打开命令行
  2. 输入命令
  3. 命令是"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()

热点内容
可以上传球球的照片 发布:2024-11-05 15:42:59 浏览:738
拉箱怎么改密码 发布:2024-11-05 15:38:02 浏览:862
http怎么配置 发布:2024-11-05 15:02:45 浏览:461
12级缓存 发布:2024-11-05 14:52:09 浏览:578
神武4脚本 发布:2024-11-05 14:48:50 浏览:702
王者荣耀反复解压 发布:2024-11-05 14:31:58 浏览:853
存储引擎有哪些品牌 发布:2024-11-05 14:25:59 浏览:39
红薯的存储方法 发布:2024-11-05 14:17:32 浏览:757
脚本错误弹窗口在哪里 发布:2024-11-05 14:01:16 浏览:967
java微信demo 发布:2024-11-05 13:50:31 浏览:238