大家好,又见面了,我是你们的朋友全栈君。如果您正在找激活码,请点击查看最新教程,关注关注公众号 “全栈程序员社区” 获取激活教程,可能之前旧版本教程已经失效.最新Idea2022.1教程亲测有效,一键激活。
Jetbrains全系列IDE稳定放心使用
一、什么是werkzeug
werkzeug 官方的介绍说是一个 WSGI 工具包,不是一个web服务器,也不是一个web框架,它可以作为一个 Web 框架的底层库,因为它封装好了很多 Web 框架的东西,例如 Request,Response 等等;例如我最常用的 Flask 框架就是一 Werkzeug 为基础开发的。
二、Werkzeug实现密码校验功能
使用Werkzeug实现密码散列,最关键的是使用其中security模块的generater_password_hash()和check_password_hash()。
from werkzeug.security import generate_password_hash,check_password_hash
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)#id列
username = db.Column(db.String(64), unique=True, index=True) #username列
role_id = db.Column(db.Integer, db.ForeignKey('roles.id')) #role_id列
password_hash = db.Column(db.String(128)) #密码hash列
@property
def password(self): #访问password属性
raise AttributeError('password is not a readable attribute')
# 对保存到数据库中的密码进行加盐
# 什么是盐?
# 通过一个随机字符串或指定字符串与原有字符串进行混淆处理,等到一个新的字符串,这个过程称为加盐处理。
@password.setter
def password(self,password): #设置password属性
self.password_hash = generate_password_hash(password) #默认加盐了
# 输入密码时进行校验
def verify_password(self,password):#验证密码
return check_password_hash(self.password_hash,password)
def __repr__(self):
return '<user r="">' % self.username</user>
1、generate_password_hash(password, method=pbkdf2:sha1, slat_length=8)
method指定哈希变化的算法,默认sha1,salt_length指定‘盐的长度’,默认是8位。password是必须指定的。
返回计算得出的128位哈希值
2、check_password_hash(hash,password)
hash是密码散列值(一般存于数据库),password是输入需比较的密码。
返回的是True或者False
三、local 模块
1、简介
在local
模块中,Werkzeug实现了类似Python标准库中threading.local
的功能。threading.local
是线程局部变量,也就是每个线程的私有变量,具有线程隔离性,可以通过线程安全的方式获取或者改变线程中的变量。参照threading.local
,Werkzeug实现了比thread.local
更多的功能。
总结起来: 以上文档解释了对于“并发”问题,多线程并不是唯一的方式,在Python中还有“协程”。“协程”的一个显著特点在于是一个线程执行,一个线程可以存在多个协程。也可以理解为:协程会复用线程。对于
WSGI
应用来说,如果每一个线程处理一个请求,那么thread.local
完全可以处理,但是如果每一个协程处理一个请求,那么一个线程中就存在多个请求,用thread.local
变量处理起来会造成多个请求间数据的相互干扰。
对于上面问题,Werkzeug库解决的办法是local
模块。local
模块实现了四个类:
Local
LocalStack
LocalProxy
LocalManager
本文重点介绍前两个类的实现。
2、Local类
Local
类能够用来存储线程的私有变量。在功能上这个threading.local
类似。与之不同的是,Local
类支持Python的协程。在Werkzeug库的local模块中,Local
类实现了一种数据结构,用来保存线程的私有变量,对于其具体形式,可以参考它的构造函数:
class Local(object):
__slots__ = ('__storage__', '__ident_func__')
def __init__(self):
object.__setattr__(self, '__storage__', {})
object.__setattr__(self, '__ident_func__', get_ident)
从上面类定义可以看出,Local
类具有两个属性:__storage__
和__ident_func__
。从构造函数来看,__storage__
是一个字典,而__ident_func__
是一个函数,用来识别当前线程或协程。
1. __ident_func__
关于当前线程或协程的识别,local
模块引入get_ident
函数。如果支持协程,则从greenlet
库中导入相关函数,否则从thread
库中导入相关函数。调用get_ident
将返回一个整数,这个整数可以确定当前线程或者协程。
try:
from greenlet import getcurrent as get_ident
except ImportError:
try:
from thread import get_ident
except ImportError:
from _thread import get_ident
2. __storage__
__storage__
是一个字典,用来存储不同的线程/协程,以及这些线程/协程中的变量。以下是一个简单的多线程的例子,用来说明__storage__
的具体结构。
import threading
from werkzeug.local import Local
l = Local()
l.__storage__
def add_arg(arg, i):
l.__setattr__(arg, i)
for i in range(3):
arg = 'arg' + str(i)
t = threading.Thread(target=add_arg, args=(arg, i))
t.start()
l.__storage__
上面的例子,具体分析为:
- 首先,代码创建了一个
Local
的实例l
,并且访问它的__storage__
属性。由于目前还没有数据,所以l.__storage__
的结果为{}
; - 代码创建了3个线程,每个线程均运行
add_arg(arg, i)
函数。这个函数会为每个线程创建一个变量,并对其赋值; - 最后,再次访问
l.__storage__
。这次,l
实例中将包含3个线程的信息。其结果为:
{20212: {'arg0': 0}, 20404: {'arg1': 1}, 21512: {'arg2': 2}}
从以上结果可以看出,__storage__
这个字典的键表示不同的线程(通过get_ident
函数获得线程标识数值),而值表示对应线程中的变量。这种结构将不同的线程分离开来。当某个线程要访问该线程的变量时,便可以通过get_ident
函数获得线程标识数值,进而可以在字典中获得该键对应的值信息了。
3、LocalStack类
LocalStack
类和Local
类类似,但是它实现了栈数据结构。
在LocalStack
类初始化的时候,便会创建一个Local
实例,这个实例用于存储线程/协程的变量。与此同时,LocalStack
类还实现了push
、pop
、top
等方法或属性。调用这些属性或者方法时,该类会根据当前线程或协程的标识数值,在Local
实例中对相应的数值进行操作。以下还是以一个多线程的例子进行说明:
from werkzeug.local import LocalStack, LocalProxy
import logging, random, threading, time
# 定义logging配置
logging.basicConfig(level=logging.DEBUG,
format='(%(threadName)-10s) %(message)s',
)
# 生成一个LocalStack实例_stack
_stack = LocalStack()
# 定义一个RequestConetxt类,它包含一个上下文环境。
# 当调用这个类的实例时,它会将这个上下文对象放入
# _stack栈中去。当退出该上下文环境时,栈会pop其中
# 的上下文对象。
class RequestConetxt(object):
def __init__(self, a, b, c):
self.a = a
self.b = b
self.c = c
def __enter__(self):
_stack.push(self)
def __exit__(self, exc_type, exc_val, exc_tb):
if exc_tb is None:
_stack.pop()
def __repr__(self):
return '%s, %s, %s' % (self.a, self.b, self.c)
# 定义一个可供不同线程调用的方法。当不同线程调用该
# 方法时,首先会生成一个RequestConetxt实例,并在这
# 个上下文环境中先将该线程休眠一定时间,之后打印出
# 目前_stack中的信息,以及当前线程中的变量信息。
# 以上过程会循环两次。
def worker(i):
with request_context(i):
for j in range(2):
pause = random.random()
logging.debug('Sleeping %0.02f', pause)
time.sleep(pause)
logging.debug('stack: %s' % _stack._local.__storage__.items())
logging.debug('ident_func(): %d' % _stack.__ident_func__())
logging.debug('a=%s; b=%s; c=%s' %
(LocalProxy(lambda: _stack.top.a),
LocalProxy(lambda: _stack.top.b),
LocalProxy(lambda: _stack.top.c))
)
logging.debug('Done')
# 调用该函数生成一个RequestConetxt对象
def request_context(i):
i = str(i+1)
return RequestConetxt('a'+i, 'b'+i, 'c'+i)
# 在程序最开始显示_stack的最初状态
logging.debug('Stack Initial State: %s' % _stack._local.__storage__.items())
# 产生两个线程,分别调用worker函数
for i in range(2):
t = threading.Thread(target=worker, args=(i,))
t.start()
main_thread = threading.currentThread()
for t in threading.enumerate():
if t is not main_thread:
t.join()
# 在程序最后显示_stack的最终状态
logging.debug('Stack Finally State: %s' % _stack._local.__storage__.items())
以上例子的具体分析过程如下:
- 首先,先创建一个
LocalStack
实例_stack
,这个实例将存储线程/协程的变量信息; - 在程序开始运行时,先检查
_stack
中包含的信息; - 之后创建两个线程,分别执行
worker
函数; worker
函数首先会产生一个上下文对象,这个上下文对象会放入_stack
中。在这个上下文环境中,程序执行一些操作,打印一些数据。当退出上下文环境时,_stack
会pop该上下文对象。- 在程序结束时,再次检查
_stack
中包含的信息。
运行上面的测试例子,产生结果如下:
(MainThread) Stack Initial State: []
(Thread-1 ) Sleeping 0.31
(Thread-2 ) Sleeping 0.02
(Thread-2 ) stack: [(880, {'stack': [a1, b1, c1]}), (13232, {'stack': [a2, b2, c2]})]
(Thread-2 ) ident_func(): 13232
(Thread-2 ) a=a2; b=b2; c=c2
(Thread-2 ) Sleeping 0.49
(Thread-1 ) stack: [(880, {'stack': [a1, b1, c1]}), (13232, {'stack': [a2, b2, c2]})]
(Thread-1 ) ident_func(): 880
(Thread-1 ) a=a1; b=b1; c=c1
(Thread-1 ) Sleeping 0.27
(Thread-2 ) stack: [(880, {'stack': [a1, b1, c1]}), (13232, {'stack': [a2, b2, c2]})]
(Thread-2 ) ident_func(): 13232
(Thread-2 ) a=a2; b=b2; c=c2
(Thread-2 ) Done
(Thread-1 ) stack: [(880, {'stack': [a1, b1, c1]})]
(Thread-1 ) ident_func(): 880
(Thread-1 ) a=a1; b=b1; c=c1
(Thread-1 ) Done
(MainThread) Stack Finally State: []
注意:
- 当两个线程在运行时,
_stack
中会存储这两个线程的信息,每个线程的信息都保存在类似{'stack': [a1, b1, c1]}
的结构中(注:stack键对应的是放入该栈中的对象,此处为了方便打印了该对象的一些属性)。 - 当线程在休眠和运行中切换时,通过线程的标识数值进行区分不同线程,线程1运行时它通过标识数值只会对属于该线程的数值进行操作,而不会和线程2的数值混淆,这样便起到线程隔离的效果(而不是通过锁的方式)。
- 由于是在一个上下文环境中运行,当线程执行完毕时,
_stack
会将该线程存储的信息删除掉。在上面的运行结果中可以看出,当线程2运行结束后,_stack
中只包含线程1的相关信息。当所有线程都运行结束,_stack
的最终状态将为空。
四、wrappers模块
1、简介
Werkzeug库中的wrappers
模块主要对request
和response
进行封装。request
包含了客户端发往服务器的所有请求信息,response
包含了web应用返回给客户端的所有信息。wrappers
模块对请求和响应的封装简化了客户端、服务器和web应用通信的流程。本文主要介绍wrappers
模块中重要的类。
2、BaseRequest
BaseRequest
是一个非常基础的请求类,它可以和其他的“混合”类结合在一起构建复杂的请求类。只要传递一个环境变量environ
(由WSGI
服务器根据请求产生),便可以构造一个BaseRequest
实例。其构造函数如下:
def __init__(self, environ, populate_request=True, shallow=False):
self.environ = environ
if populate_request and not shallow:
self.environ['werkzeug.request'] = self
self.shallow = shallow
初始化后,形成的实例request
便具有了一些属性可以访问,这些属性只能以“只读”的方式访问。例如:
- url_charset
- want_form_data_parsed
- stream
- args
- data
- form
- values
- files
- cookies
- headers
- path
- full_path
- script_root
- url
- base_url
- url_root
- host_url
- host
- access_route
- remote_addr
BaseRequest
中还有两个类方法比较常用:
from_values(cls, *args, kwargs)**
@classmethod
def from_values(cls, *args, **kwargs):
"""Create a new request object based on the values provided. If
environ is given missing values are filled from there. This method is
useful for small scripts when you need to simulate a request from an URL.
Do not use this method for unittesting, there is a full featured client
object (:class:`Client`) that allows to create multipart requests,
support for cookies etc.
This accepts the same options as the
:class:`~werkzeug.test.EnvironBuilder`.
.. versionchanged:: 0.5
This method now accepts the same arguments as
:class:`~werkzeug.test.EnvironBuilder`. Because of this the
`environ` parameter is now called `environ_overrides`.
:return: request object
"""
from werkzeug.test import EnvironBuilder
charset = kwargs.pop('charset', cls.charset)
kwargs['charset'] = charset
builder = EnvironBuilder(*args, **kwargs)
try:
return builder.get_request(cls)
finally:
builder.close()
这个类方法可以根据提供的参数构建一个请求。
application(cls, f)
@classmethod
def application(cls, f):
"""Decorate a function as responder that accepts the request as first
argument. This works like the :func:`responder` decorator but the
function is passed the request object as first argument and the
request object will be closed automatically::
@Request.application
def my_wsgi_app(request):
return Response('Hello World!')
:param f: the WSGI callable to decorate
:return: a new WSGI callable
"""
#: return a callable that wraps the -2nd argument with the request
#: and calls the function with all the arguments up to that one and
#: the request. The return value is then called with the latest
#: two arguments. This makes it possible to use this decorator for
#: both methods and standalone WSGI functions.
def application(*args):
request = cls(args[-2])
with request:
return f(*args[:-2] + (request,))(*args[-2:])
return update_wrapper(application, f)
这个类方法是一个装饰器,可以用来装饰WSGI
可调用对象或函数。
以上属性和方法的具体用法可以参考 Request——werkzeug文档。
3、BaseResponse
BaseResponse
类是一个响应类,用它可以封装一个response
对象。response
对象最大的特点是它是一个WSGI
应用。
在之前介绍WSGI
规范的文章中曾介绍过Web服务器网关
,它简化了服务器和web应用之间的通信过程,它要求服务器和web应用要遵循WSGI
规范进行开发。对于web应用而言,应用应该实现一个函数或者一个可调用对象,这样WSGI
服务器可以通过调用myWebApp(environ, start_response)
从web应用获得响应内容。
response
响应对象就是这样一个WSGI
应用对象。在其实现过程中有一个__call__
方法,可以实现对一个response
对象的调用。代码如下:
def __call__(self, environ, start_response):
"""Process this response as WSGI application.
:param environ: the WSGI environment.
:param start_response: the response callable provided by the WSGI
server.
:return: an application iterator
"""
app_iter, status, headers = self.get_wsgi_response(environ)
start_response(status, headers)
return app_iter
这样,我们就可以很清楚地理解WSGI
应用的实现过程。下面是一个非常简单的WSGI
应用。
from werkzeug.wrappers import Request, Response
def application(environ, start_response):
request = Request(environ)
response = Response("Hello %s!" % request.args.get('name', 'World!'))
return response(environ, start_response)
上面的小例子的实现步骤分析:
- 根据传入web应用的
environ
构造请求对象request
; - web应用构造响应对象
response
; - 调用响应对象
response
。调用过程中产生三个值:app_iter
、status
、headers
,其中status
和headers
作为参数传递给函数start_response
用于生成响应报文首行的相关信息,而app_iter
作为响应的内容(它是一个可迭代对象)返回给WSGI网关
; WSGI网关
将返回的信息组成响应首行、响应首部、响应主体等,形成响应报文发回给客户端。
BaseResponse
类中还有一些属性和方法,以下属性和方法的具体用法可以参考Response——werkzeug文档。
- 属性
- status_code
- status
- data
- is_stream
- is_sequence
- ······
- 方法
- call_on_close(func)
- close()
- freeze()
- force_type() 类方法
- from_app() 类方法
- set_data()
- get_data()
_ensure_sequence()
- make_sequence()
- iter_encoded()
- calculate_content_length()
- set_cookie()
- delete_cookie()
- get_wsgi_headers(environ)
- get_app_iter(environ)
- get_wsgi_response(environ)
__call__(environ, start_response)
- ······
4、Mixin类
BaseRequest
类和BaseResponse
类是请求和响应最基础的类。wrappers
模块中还提供了一些Mixin
类,用于扩展请求类和响应类。
有关请求类的Mixin
类主要有:
AcceptMixin
类 ——请求报文中关于客户端希望接收的数据类型的类。ETagRequestMixin
类 ——请求报文中关于Etag和Cache的类。UserAgentMixin
类 ——请求报文中关于user_agent的类。AuthorizationMixin
类 ——请求报文中关于认证的类。CommonRequestDescriptorsMixin
类 ——通过这个类可以获取请求首部中的相关信息。
有关响应类的Mixin
类主要有:
ETagResponseMixin
类 ——为响应增加Etag和Cache控制的类。ResponseStreamMixin
类 ——为响应可迭代对象提供一个“只写”的接口的类。CommonResponseDescriptorsMixin
类 ——通过这个类可以获取响应首部中的相关信息。WWWAuthenticateMixin
类 ——为响应提供认证的类。
5、Request和Response
终于讲到Request
类和Response
类了。
Request
类继承自BaseRequest
类,并且结合一些请求相关的Mixin
类,具体如下:
class Request(BaseRequest, AcceptMixin, ETagRequestMixin,
UserAgentMixin, AuthorizationMixin,
CommonRequestDescriptorsMixin)
Response
类继承自BaseResponse
类,并且结合一些响应相关的Mixin
类,具体如下:Python
class Response(BaseResponse, ETagResponseMixin, ResponseStreamMixin,
CommonResponseDescriptorsMixin,
WWWAuthenticateMixin)
至此,可以从wrappers
模块中引入Request
类和Response
用于构建请求对象和响应对象。
五、routing模块
Werkzeug库的routing
模块的主要功能在于URL解析。对于WSGI
应用来讲,不同的URL对应不同的视图函数,routing
模块则会对请求信息的URL进行解析并匹配,触发URL对应的视图函数,以此生成一个响应信息。routing
模块的解析和匹配功能主要体现在三个类上:Rule
、Map
和MapAdapter
。
1、Rule
类
Rule
类继承自RuleFactory
类。一个Rule
的实例代表一个URL模式,一个WSGI
应用可以处理很多不同的URL模式,这也就是说可以产生很多不同的Rule
实例。这些Rule
实例最终会作为参数传递给Map
类,形成一个包含所有URL模式的对象,通过这个对象可以解析并匹配请求对应的视图函数。
关于Rule
类有一些常用的方法:
empty()
——在实际情况中,Rule
实例会和一个Map
实例进行绑定。通过empty()
方法可以将Rule
实例和Map
实例解除绑定。get_empty_kwargs()
——在empty()
方法中调用,可以获得之前Rule
实例的参数,以便重新构造一个Rule
实例。get_rules(map)
——这个方法是对RuleFactory
类中get_rules
方法的重写,返回Rule
实例本身。refresh()
——当修改Rule
实例(URL规则)后可以调用该方法,以便更新Rule
实例和Map
实例的绑定关系。bind(map, rebind=False)
——将Rule
实例和一个Map
实例进行绑定,这个方法会调用complie()
方法,会给Rule
实例生成一个正则表达式。complie()
——根据Rule
实例的URL模式,生成一个正则表达式,以便后续对请求的path
进行匹配。match(path)
——将Rule
实例和给定的path
进行匹配。在调用complie()
方法生成的正则表达式将会对path
进行匹配。如果匹配,将返回这个path
中的参数,以便后续过程使用。如果不匹配,将会由其他的Rule
实例和这个path
进行匹配。
注意: 在对给定的URL进行匹配的过程中,会使用一些Converters
。关于Converters
的信息后续加以介绍。
2、Map
类
通过Map
类构造的实例可以存储所有的URL规则,这些规则是Rule
类的实例。Map
实例可以 通过后续的调用和给定的URL进行匹配。
关于Map
类有一些常用的方法:
add(rulefactory)
——这个方法在构造Map
实例的时候就会调用,它会将所有传入Map
类中的Rule
实例和该Map
实例建立绑定关系。该方法还会调用Rule
实例的bind
方法。bind
方法 ——这个方法会生成一个MapAdapter
实例,传入MapAdapter
的包括一些请求信息,这样可以调用MapAdapter
实例的方法匹配给定URL。bind_to_environ
方法 ——通过解析请求中的environ
信息,然后调用上面的bind
方法,最终会生成一个MapAdapter
实例。
3、MapAdapter
类
MapAdapter
类执行URL匹配的具体工作。关于MapAdapter
类有一些常用的方法:
dispatch
方法 ——该方法首先会调用MapAdapter
实例的match()
方法,如果有匹配的Rule
,则会执行该Rule
对应的视图函数。match
方法 ——该方法将会进行具体的URL匹配工作。它会将请求中的url和MapAdapter
实例中的所有Rule
进行匹配,如果有匹配成功的,则返回该Rule
对应的endpoint
和一些参数rv
。endpoint
一般会对应一个视图函数,返回的rv
可以作为参数传入视图函数中。
4、示例
为了说明routing
模块的工作原理,这里使用Werkzeug
文档中的一个例子,稍加改动后如下所示:
from werkzeug.routing import Map, Rule, NotFound, RequestRedirect, HTTPException
url_map = Map([
Rule('/', endpoint='blog/index'),
Rule('/<int:year>/', endpoint='blog/archive'),
Rule('/<int:year>/<int:month>/', endpoint='blog/archive'),
Rule('/<int:year>/<int:month>/<int:day>/', endpoint='blog/archive'),
Rule('/<int:year>/<int:month>/<int:day>/<slug>',
endpoint='blog/show_post'),
Rule('/about', endpoint='blog/about_me'),
Rule('/feeds/', endpoint='blog/feeds'),
Rule('/feeds/<feed_name>.rss', endpoint='blog/show_feed')
])
def application(environ, start_response):
urls = url_map.bind_to_environ(environ)
try:
endpoint, args = urls.match()
except HTTPException, e:
return e(environ, start_response)
start_response('200 OK', [('Content-Type', 'text/plain')])
return ['Rule points to %r with arguments %r' % (endpoint, args)]
if __name__ == '__main__':
from werkzeug.serving import run_simple
run_simple('localhost', 4000, application)
这里我们使用werkzeug
自带的服务器模块构造了一个Web服务器,并且设计了一个简单的WSGI
应用——application
。这个Web服务器可以根据URL的不同返回不同的结果。关于服务器的构造这里不再赘述,以下部分简单对URL Routing
过程进行分析:
1. 设计URL模式
设计URL模式的过程就是构造Rule
实例的过程。上面的例子中我们构造了8个Rule
实例,分别对应8个不同的URL模式。每个Rule
实例还对应一个endpoint
,这个endpoint
可以和视图函数进行对应,以便访问某个URL时,可以触发与之对应的视图函数。下面的例子展示了endpoint
和视图函数的对应关系。
from werkzeug.wrappers import Response
from werkzeug.routing import Map, Rule
def on_index(request):
return Response('Hello from the index')
url_map = Map([Rule('/', endpoint='index')])
views = {'index': on_index}
2. 构造Map实例
构造Map实例时,会调用它的add(rulefactory)
方法。这个方法会在Map实例和各个Rule实例之间建立绑定关系,并通过调用Rule实例的bind()
方法为每个Rule实例生成一个正则表达式。
例如,对于'/about'
这个URL,它对应的正则表达式为:
1 |
‘^\\|\\/about$’ |
对于'/<int:year>/<int:month>/<int:day>/'
这个URL,它对应的正则表达式为:
1 |
‘^\\|\\/(?P<year>\\d+)\\/(?P<month>\\d+)\\/(?P<day>\\d+)(?<!/)(?P<__suffix__>/?)$’ |
3. 构造MapAdapter实例
在设计WSGI
应用时,上述例子通过url_map.bind_to_environ(environ)
构建了一个MapAdapter实例。这个实例将请求的相关信息和已经创建好的Map
实例放在一起,以便进行URL匹配。
进行URL匹配的过程是通过调用MapAdapter实例的match()
方法进行的。实质上,这个方法会将请求中的path
传入到所有Rule实例的match(path)
方法中,经过正则表达式的匹配来分析path
是否和某个Rule实例匹配。如果匹配则返回对应的endpoint
和其他的参数,这可以作为参数传入视图函数。
4. 访问URL可得相关结果
之后,访问URL可以得到相对应的结果。
例如,访问http://localhost:4000/2017/
,可以得到:
Rule points to 'blog/archive' with arguments {'year': 2017}
访问http://localhost:4000/2017/3/20/
,可以得到:
Rule points to 'blog/archive' with arguments {'month': 3, 'day': 20, 'year': 2017}
访问http://localhost:4000/about
,可以得到:
Rule points to 'blog/about_me' with arguments {}
六、utils模块
utils是一个工具模块,很多方法都用在response和request模块中。当设计中间件的时候也需要调用某些方法。
secure_filename() 函数处理文件名,该函数只返回ASCII字符,非ASCII字符会被过滤掉。中文文件名需要转换成英文,可以使用pypinyin库 来转换。
发布者:全栈程序员-用户IM,转载请注明出处:https://javaforall.cn/184953.html原文链接:https://javaforall.cn
【正版授权,激活自己账号】: Jetbrains全家桶Ide使用,1年售后保障,每天仅需1毛
【官方授权 正版激活】: 官方授权 正版激活 支持Jetbrains家族下所有IDE 使用个人JB账号...