python设置时间步长与时间离散格式_python怎么定义时间

Python 的 Decorator在使用上和Java/C#的Annotation很相似,就是在方法名前面加一个@XXX注解来为这个方法装饰一些东西。但是,Java/C#的Annotation也很让人望而却步,太TMD的复杂了,你要玩它,你需要了解一堆Annotation的类库文档,让人感觉就是在学另外一门语言。

而Python使用了一种相对于Decorator Pattern和Annotation来说非常优雅的方法,这种方法不需要你去掌握什么复杂的OO模型或是Annotation的各种类库规定,完全就是语言层面的玩法:一种函数式编程的技巧。如果你看过本站的《函数式编程》,你一定会为函数式编程的那种“描述你想干什么,而不是描述你要怎么去实现”的编程方式感到畅快。(如果你不了解函数式编程,那在读本文之前,还请你移步去看看《函数式编程》) 好了,我们先来点感性认识,看一个Python修饰器的Hello World的代码。

Hello World

下面是代码:文件名:hello.py

def hello(fn):

def wrapper():

print "hello, %s" % fn.__name__

fn()

print "goodby, %s" % fn.__name__

return wrapper

@hellodef foo():

print "i am foo"

foo()

当你运行代码,你会看到如下输出:

[chenaho@chenhao-air]$ python hello.pyhello, fooi am foogoodby, foo

你可以看到如下的东西:

1)函数foo前面有个@hello的“注解”,hello就是我们前面定义的函数hello

2)在hello函数中,其需要一个fn的参数(这就用来做回调的函数)

3)hello函数中返回了一个inner函数wrapper,这个wrapper函数回调了传进来的fn,并在回调前后加了两条语句。

Decorator 的本质

对于Python的这个@注解语法糖- Syntactic Sugar 来说,当你在用某个@decorator来修饰某个函数func时,如下所示:

@decoratordef func():

pass

其解释器会解释成下面这样的语句:

func = decorator(func)

尼玛,这不就是把一个函数当参数传到另一个函数中,然后再回调吗?是的,但是,我们需要注意,那里还有一个赋值语句,把decorator这个函数的返回值赋值回了原来的func。 根据《函数式编程》中的first class functions中的定义的,你可以把函数当成变量来使用,所以,decorator必需得返回了一个函数出来给func,这就是所谓的higher order function 高阶函数,不然,后面当func()调用的时候就会出错。 就我们上面那个hello.py里的例子来说,

@hellodef foo():

print "i am foo"

被解释成了:

foo = hello(foo)

是的,这是一条语句,而且还被执行了。你如果不信的话,你可以写这样的程序来试试看:

def fuck(fn):

print "fuck %s!" % fn.__name__[::-1].upper()

@fuckdef wfg():

pass

没了,就上面这段代码,没有调用wfg()的语句,你会发现, fuck函数被调用了,而且还很NB地输出了我们每个人的心声!

再回到我们hello.py的那个例子,我们可以看到,hello(foo)返回了wrapper()函数,所以,foo其实变成了wrapper的一个变量,而后面的foo()执行其实变成了wrapper()。

知道这点本质,当你看到有多个decorator或是带参数的decorator,你也就不会害怕了。

比如:多个decorator

@decorator_one@decorator_twodef func():

pass

相当于:

func = decorator_one(decorator_two(func))

比如:带参数的decorator:

@decorator(arg1, arg2)def func():

pass

相当于:

func = decorator(arg1,arg2)(func)

这意味着decorator(arg1, arg2)这个函数需要返回一个“真正的decorator”。

带参数及多个Decrorator

我们来看一个有点意义的例子:html.py

def makeHtmlTag(tag, args, *kwds):

def real_decorator(fn):

css_class = " class='{0}'".format(kwds["css_class"])

if "css_class" in kwds else ""

def wrapped(*args, **kwds):

return "" + fn(*args, **kwds) + ""+tag+">"

return wrapped

return real_decorator

@makeHtmlTag(tag="b", css_class="bold_css")@makeHtmlTag(tag="i", css_class="italic_css")def hello():

return "hello world"

print hello()

输出:

hello world

在上面这个例子中,我们可以看到:makeHtmlTag有两个参数。所以,为了让 hello = makeHtmlTag(arg1, arg2)(hello) 成功,makeHtmlTag 必需返回一个decorator(这就是为什么我们在makeHtmlTag中加入了real_decorator()的原因),这样一来,我们就可以进入到 decorator 的逻辑中去了—— decorator得返回一个wrapper,wrapper里回调hello。看似那个makeHtmlTag() 写得层层叠叠,但是,已经了解了本质的我们觉得写得很自然。

你看,Python的Decorator就是这么简单,没有什么复杂的东西,你也不需要了解过多的东西,使用起来就是那么自然、体贴、干爽、透气,独有的速效凹道和完美的吸收轨迹,让你再也不用为每个月的那几天感到焦虑和不安,再加上贴心的护翼设计,量多也不用当心。对不起,我调皮了。

什么,你觉得上面那个带参数的Decorator的函数嵌套太多了,你受不了。好吧,没事,我们看看下面的方法。

class式的 Decorator

首先,先得说一下,decorator的class方式,还是看个示例:

class myDecorator(object):

def __init__(self, fn):

print "inside myDecorator.__init__()"

self.fn = fn

def __call__(self):

self.fn()

print "inside myDecorator.__call__()"

@myDecoratordef aFunction():

print "inside aFunction()"

print "Finished decorating aFunction()"

aFunction()

输出:

inside myDecorator.__init__()

Finished decorating aFunction()

inside aFunction()

inside myDecorator.__call__()

上面这个示例展示了,用类的方式声明一个decorator。我们可以看到这个类中有两个成员:1)一个是__init__(),这个方法是在我们给某个函数decorator时被调用,所以,需要有一个fn的参数,也就是被decorator的函数。2)一个是__call__(),这个方法是在我们调用被decorator函数时被调用的。上面输出可以看到整个程序的执行顺序。

这看上去要比“函数式”的方式更易读一些。

下面,我们来看看用类的方式来重写上面的html.py的代码:html.py

class makeHtmlTagClass(object):

def __init__(self, tag, css_class=""):

self._tag = tag

self._css_class = " class='{0}'".format(css_class)

if css_class !="" else ""

def __call__(self, fn):

def wrapped(*args, **kwargs):

return ""

+ fn(*args, **kwargs) + "" + self._tag + ">"

return wrapped

@makeHtmlTagClass(tag="b", css_class="bold_css")@makeHtmlTagClass(tag="i", css_class="italic_css")def hello(name):

return "Hello, {}".format(name)

print hello("Hao Chen")

上面这段代码中,我们需要注意这几点:1)如果decorator有参数的话,__init__() 成员就不能传入fn了,而fn是在__call__的时候传入的。2)这段代码还展示了 wrapped(args, *kwargs) 这种方式来传递被decorator函数的参数。(其中:args是一个参数列表,kwargs是参数dict,具体的细节,请参考Python的文档或是StackOverflow的这个问题,这里就不展开了)

用Decorator设置函数的调用参数

你有三种方法可以干这个事:

第一种,通过 **kwargs,这种方法decorator会在kwargs中注入参数。

def decorate_A(function):

def wrap_function(*args, **kwargs):

kwargs['str'] = 'Hello!'

return function(*args, **kwargs)

return wrap_function

@decorate_Adef print_message_A(args, *kwargs):

print(kwargs['str'])

print_message_A()

第二种,约定好参数,直接修改参数

def decorate_B(function):

def wrap_function(*args, **kwargs):

str = 'Hello!'

return function(str, *args, **kwargs)

return wrap_function

@decorate_Bdef print_message_B(str, args, *kwargs):

print(str)

print_message_B()

第三种,通过 *args 注入

def decorate_C(function):

def wrap_function(*args, **kwargs):

str = 'Hello!'

#args.insert(1, str)

args = args +(str,)

return function(*args, **kwargs)

return wrap_function

class Printer:

@decorate_C

def print_message(self, str, *args, **kwargs):

print(str)

p = Printer()p.print_message()

Decorator的副作用

到这里,我相信你应该了解了整个Python的decorator的原理了。

相信你也会发现,被decorator的函数其实已经是另外一个函数了,对于最前面那个hello.py的例子来说,如果你查询一下foo.__name__的话,你会发现其输出的是“wrapper”,而不是我们期望的“foo”,这会给我们的程序埋一些坑。所以,Python的functool包中提供了一个叫wrap的decorator来消除这样的副作用。下面是我们新版本的hello.py。文件名:hello.py

from functools import wrapsdef hello(fn):

@wraps(fn)

def wrapper():

print "hello, %s" % fn.__name__

fn()

print "goodby, %s" % fn.__name__

return wrapper

@hellodef foo():

'''foo help doc'''

print "i am foo"

pass

foo()print foo.__name__ #输出 fooprint foo.__doc__ #输出 foo help doc

当然,即使是你用了functools的wraps,也不能完全消除这样的副作用。

来看下面这个示例:

from inspect import getmembers, getargspecfrom functools import wraps

def wraps_decorator(f):

@wraps(f)

def wraps_wrapper(*args, **kwargs):

return f(*args, **kwargs)

return wraps_wrapper

class SomeClass(object):

@wraps_decorator

def method(self, x, y):

pass

obj = SomeClass()for name, func in getmembers(obj, predicate=inspect.ismethod):

print "Member Name: %s" % name

print "Func Name: %s" % func.func_name

print "Args: %s" % getargspec(func)[0]

输出:

Member Name: method

Func Name: method

Args: []

你会发现,即使是你你用了functools的wraps,你在用getargspec时,参数也不见了。

要修正这一问,我们还得用Python的反射来解决,下面是相关的代码:

def get_true_argspec(method):

argspec = inspect.getargspec(method)

args = argspec[0]

if args and args[0] == 'self':

return argspec

if hasattr(method, '__func__'):

method = method.__func__

if not hasattr(method, 'func_closure') or method.func_closure is None:

raise Exception("No closure for method.")

method = method.func_closure[0].cell_contents

return get_true_argspec(method)

当然,我相信大多数人的程序都不会去getargspec。所以,用functools的wraps应该够用了。

一些decorator的示例

好了,现在我们来看一下各种decorator的例子:

给函数调用做缓存

这个例实在是太经典了,整个网上都用这个例子做decorator的经典范例,因为太经典了,所以,我这篇文章也不能免俗。

from functools import wrapsdef memo(fn):

cache = {}

miss = object()

@wraps(fn)

def wrapper(*args):

result = cache.get(args, miss)

if result is miss:

result = fn(*args)

cache[args] = result

return result

return wrapper

@memodef fib(n):

if n < 2:

return n

return fib(n - 1) + fib(n - 2)

上面这个例子中,是一个斐波拉契数例的递归算法。我们知道,这个递归是相当没有效率的,因为会重复调用。比如:我们要计算fib(5),于是其分解成fib(4) + fib(3),而fib(4)分解成fib(3)+fib(2),fib(3)又分解成fib(2)+fib(1)…… 你可看到,基本上来说,fib(3), fib(2), fib(1)在整个递归过程中被调用了两次。

而我们用decorator,在调用函数前查询一下缓存,如果没有才调用了,有了就从缓存中返回值。一下子,这个递归从二叉树式的递归成了线性的递归。

Profiler的例子

这个例子没什么高深的,就是实用一些。

import cProfile, pstats, StringIO

def profiler(func):

def wrapper(*args, **kwargs):

datafn = func.__name__ + ".profile" # Name the data file

prof = cProfile.Profile()

retval = prof.runcall(func, *args, **kwargs)

#prof.dump_stats(datafn)

s = StringIO.StringIO()

sortby = 'cumulative'

ps = pstats.Stats(prof, stream=s).sort_stats(sortby)

ps.print_stats()

print s.getvalue()

return retval

return wrapper

注册回调函数

下面这个示例展示了通过URL的路由来调用相关注册的函数示例:

class MyApp():

def __init__(self):

self.func_map = {}

def register(self, name):

def func_wrapper(func):

self.func_map[name] = func

return func

return func_wrapper

def call_method(self, name=None):

func = self.func_map.get(name, None)

if func is None:

raise Exception("No function registered against - " + str(name))

return func()

app = MyApp()

@app.register('/')def main_page_func():

return "This is the main page."

@app.register('/next_page')def next_page_func():

return "This is the next page."

print app.call_method('/')print app.call_method('/next_page')

注意:1)上面这个示例中,用类的实例来做decorator。2)decorator类中没有__call__(),但是wrapper返回了原函数。所以,原函数没有发生任何变化。

给函数打日志

下面这个示例演示了一个logger的decorator,这个decorator输出了函数名,参数,返回值,和运行时间。

from functools import wrapsdef logger(fn):

@wraps(fn)

def wrapper(*args, **kwargs):

ts = time.time()

result = fn(*args, **kwargs)

te = time.time()

print "function = {0}".format(fn.__name__)

print " arguments = {0} {1}".format(args, kwargs)

print " return = {0}".format(result)

print " time = %.6f sec" % (te-ts)

return result

return wrapper

@loggerdef multipy(x, y):

return x * y

@loggerdef sum_num(n):

s = 0

for i in xrange(n+1):

s += i

return s

print multipy(2, 10)print sum_num(100)print sum_num(10000000)

上面那个打日志还是有点粗糙,让我们看一个更好一点的(带log level参数的):

import inspectdef get_line_number():

return inspect.currentframe().f_back.f_back.f_lineno

def logger(loglevel):

def log_decorator(fn):

@wraps(fn)

def wrapper(*args, **kwargs):

ts = time.time()

result = fn(*args, **kwargs)

te = time.time()

print "function = " + fn.__name__,

print " arguments = {0} {1}".format(args, kwargs)

print " return = {0}".format(result)

print " time = %.6f sec" % (te-ts)

if (loglevel == 'debug'):

print " called_from_line : " + str(get_line_number())

return result

return wrapper

return log_decorator

但是,上面这个带log level参数的有两具不好的地方,1) loglevel不是debug的时候,还是要计算函数调用的时间。2) 不同level的要写在一起,不易读。

我们再接着改进:

import inspect

def advance_logger(loglevel):

def get_line_number():

return inspect.currentframe().f_back.f_back.f_lineno

def _basic_log(fn, result, *args, **kwargs):

print "function = " + fn.__name__,

print " arguments = {0} {1}".format(args, kwargs)

print " return = {0}".format(result)

def info_log_decorator(fn):

@wraps(fn)

def wrapper(*args, **kwargs):

result = fn(*args, **kwargs)

_basic_log(fn, result, args, kwargs)

return wrapper

def debug_log_decorator(fn):

@wraps(fn)

def wrapper(*args, **kwargs):

ts = time.time()

result = fn(*args, **kwargs)

te = time.time()

_basic_log(fn, result, args, kwargs)

print " time = %.6f sec" % (te-ts)

print " called_from_line : " + str(get_line_number())

return wrapper

if loglevel is "debug":

return debug_log_decorator

else:

return info_log_decorator

你可以看到两点,1)我们分了两个log level,一个是info的,一个是debug的,然后我们在外尾根据不同的参数返回不同的decorator。2)我们把info和debug中的相同的代码抽到了一个叫_basic_log的函数里,DRY原则。

一个MySQL的Decorator

下面这个decorator是我在工作中用到的代码,我简化了一下,把DB连接池的代码去掉了,这样能简单点,方便阅读。

import umysqlfrom functools import wraps

class Configuraion:

def __init__(self, env):

if env == "Prod":

self.host = "coolshell.cn"

self.port = 3306

self.db = "coolshell"

self.user = "coolshell"

self.passwd = "fuckgfw"

elif env == "Test":

self.host = 'localhost'

self.port = 3300

self.user = 'coolshell'

self.db = 'coolshell'

self.passwd = 'fuckgfw'

def mysql(sql):

_conf = Configuraion(env="Prod")

def on_sql_error(err):

print err

sys.exit(-1)

def handle_sql_result(rs):

if rs.rows > 0:

fieldnames = [f[0] for f in rs.fields]

return [dict(zip(fieldnames, r)) for r in rs.rows]

else:

return []

def decorator(fn):

@wraps(fn)

def wrapper(*args, **kwargs):

mysqlconn = umysql.Connection()

mysqlconn.settimeout(5)

mysqlconn.connect(_conf.host, _conf.port, _conf.user,

_conf.passwd, _conf.db, True, 'utf8')

try:

rs = mysqlconn.query(sql, {})

except umysql.Error as e:

on_sql_error(e)

data = handle_sql_result(rs)

kwargs["data"] = data

result = fn(*args, **kwargs)

mysqlconn.close()

return result

return wrapper

return decorator

@mysql(sql = "select * from coolshell" )def get_coolshell(data):

... ...

... ..

线程异步

下面量个非常简单的异步执行的decorator,注意,异步处理并不简单,下面只是一个示例。

from threading import Threadfrom functools import wraps

def async(func):

@wraps(func)

def async_func(*args, **kwargs):

func_hl = Thread(target = func, args = args, kwargs = kwargs)

func_hl.start()

return func_hl

return async_func

if name == '__main__':

from time import sleep

@async

def print_somedata():

print 'starting print_somedata'

sleep(2)

print 'print_somedata: 2 sec passed'

sleep(2)

print 'print_somedata: 2 sec passed'

sleep(2)

print 'finished print_somedata'

def main():

print_somedata()

print 'back in main'

print_somedata()

print 'back in main'

main()

其它

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/454228.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

Python 第三方模块之 matplotlib - 绘图库

简介 matplotlib是受MATLAB的启发构建的。MATLAB是数据绘图领域广泛使用的语言和工具。MATLAB语言是面向过程的。利用函数的调用&#xff0c;MATLAB中可以轻松的利用一行命令来绘制直线&#xff0c;然后再用一系列的函数调整结果。 matplotlib有一套完全仿照MATLAB的函数形式…

python 笔记(三) 断言(assert)

用来调试程序的时候用&#xff0c;当程序有误时&#xff0c;强制抛出异常转载于:https://www.cnblogs.com/wangkeblog/p/7746022.html

网站程序员的程序员成长之路大概分几个阶段 和未来的发展

信息技术的更新速度是惊人的&#xff0c;程序员的职业生涯则是一个要求不断学习的过程&#xff0c;如何才能成为一名合格的程序员&#xff0c;一名合格的程序员需要掌握哪些技能呢&#xff1f;为此天天招生网采访到几位孳生的程序工作人员&#xff0c;就如何做好一名成功的程序…

微软P2V工具之Disk2VHD

虚拟化经过最近几年的发展&#xff0c;已经有很多的应用和服务迁移到了虚拟化的平台上了。在实施虚拟化的过程中就会涉及到将原来老旧的服务器来迁移到虚拟化平台的运行&#xff0c;这就是P2V&#xff0c;物理机转换为虚拟机。谈到P2V大家会想到很多的工具&#xff0c;例如Vmwa…

生成n套数位加减乘除_leetcode 算法汇总(四)位运算

一、 运算符& 与运算&#xff1a; 两个位都是 1 时&#xff0c;结果才为 1&#xff0c;否则为 0| 或运算&#xff1a; 两个位都是 0 时&#xff0c;结果才为 0&#xff0c;否则为 1^ 异或运算&#xff1a; 两个位相同则为 0&#xff0c;不同则为 1~ 取反运算&#xff1a;0 …

机器学习算法之 K-means、层次聚类,谱聚类

k-means 和层次聚类都属于划分聚类&#xff0c;实际中最常用的是k-means&#xff0c;k-means效果不好的情况下才会采用其他聚类 K-means算法 K-means算法&#xff0c;也称为K-平均或者K-均值&#xff0c;是一种使用广泛的最基础的聚类算法 假设输入样本为TX1,X2,…,Xm;则算法…

vue数据请求

我是vue菜鸟&#xff0c;第一次用vue做项目&#xff0c;写一些自己的理解&#xff0c;可能有些不正确&#xff0c;欢迎纠正。 vue开发环境要配置本地代理服务。把config文件加下的index.js里的dev添加一些内容&#xff0c; dev: {env: require(./dev.env),port: 8090,autoOpenB…

jetty部署多个web应用及将jetty配置成服务

通常情况下一个jetty部署一个java web应用&#xff0c;但一台服务只部署一个应用可能会造成资源浪费&#xff0c;所以有时候可能在一台服务器上要部署多个web应用。下面我们以一台server部署两个web应用为例。 服务器环境&#xff1a;安装JDK&#xff0c;2个jetyy9 重点&#x…

程序员成长的10个阶段

我的程序员成长之路 程序员的成长经历往往很相似&#xff0c;大部分的人走过了最前面相同的一段路&#xff0c;而有的人则走得更远。总结自己这些年来的历程&#xff0c;这也许能让年轻的程序员少走一些弯路&#xff0c;成长得更快&#xff1b;或许更好一些&#xff0c;能让大家…

mapper注解的主要作用_Mybatis中mapper的xml解析详解

上一篇文章分析了mapper注解关键类MapperAnnotationBuilder&#xff0c;今天来看mapper的项目了解析关键类XMLMapperBuilder。基础介绍回顾下之前是在分析configuration的初始化过程&#xff0c;已经进行到了最后一步mapperElement(root.evalNode("mappers"))&#x…

机器学习之梯度下降法(GD)和坐标轴下降法(CD)

梯度下降法 梯度下降法&#xff08;Gradient Descent, GD&#xff09;常用于求解无约束情况下凸函数&#xff08;Convex Function&#xff09;的极小值&#xff0c;是一种迭代类型的算法&#xff0c;因为凸函数只有一个极值点&#xff0c;故求解出来的极小值点就是函数的最小值…

阿里云Https部署网站

0、开始之前 文章图片很多&#xff0c;注意流量 首先你得准备好一个已经备案成功的域名&#xff0c;并且有一个在阿里云的服务器部署了的网站。 然后就是你迫切的希望升级网站为HTTPS部署。 那么我们开始吧&#xff01; 1、申请CA证书 1.1登录阿里云控制台&#xff0c;选择菜单…

mysql数据库多实例部署

本文系统&#xff1a;rhel5.8 ip : 192.168.100.150 数据库版本&#xff1a;mysql-5.6.15 1、创建部署mysql服务账号&#xff1a; 1234[rootdaf ~]# useradd -d /opt/mysql mysql [rootdaf ~]# echo "mysql" |passwd --stdin mysql Changing password for user mysq…

Python 第三方模块之 numpy.linalg - 线性代数

目录 numpy.linalg.det() 行列式 numpy.linalg.solve() 方程的解 numpy.linalg.inv() 逆矩阵 np.linalg.eig 特征值和特征向量 np.linalg.svd 奇异值分解 np.linalg.pinv 广义逆矩阵&#xff08;QR分解&#xff09; numpy.linalg模块包含线性代数的函数。使用这个模块&am…

rabbitmq direct 多个消费者_一文解析 RabbitMQ 最常用的三大模式

Direct 模式所有发送到 Direct Exchange 的消息被转发到 RouteKey 中指定的 Queue。Direct 模式可以使用 RabbitMQ 自带的 Exchange: default Exchange&#xff0c;所以不需要将 Exchange 进行任何绑定(binding)操作。消息传递时&#xff0c;RouteKey 必须完全匹配才会被队列接…

程序员成长最快的环境

除开五大或者ThoughtWorks这种要什么有什么&#xff0c;进去做打字也能光耀门楣的不谈。如果是嫁到一个普通软件公司&#xff0c;怎样的环境才能最快的成长呢&#xff1f;首先基本的 公司项目管理水平是必要的&#xff1b;其次是稳健而不保守的公司技术选型和一班能沟通的同事。…

【BZOJ4254】Aerial Tramway 树形DP

【BZOJ4254】Aerial Tramway 题意&#xff1a;给你一座山上n点的坐标&#xff0c;让你在山里建m条缆车&#xff0c;要求缆车两端的高度必须相等&#xff0c;且中间经过的点的高度都小于缆车的高度。并且不能存在一个点位于至少k条缆车的下方。求缆车的最大总长度。 n,m<200,…

C# 读取保存App.config配置文件的完整源码参考

最近出差在北京做一个小项目&#xff0c;项目里需要读取配置文件的小功能&#xff0c;觉得挺有参考意义的就把代码发上来给大家参考一下。我们选择了直接用微软的读取配置文件的方法。 这个是程序的运行设计效果&#xff0c;就是把这些参数可以进行灵活设置&#xff0c;灵活保存…

TensorFlow 简介

TensorFlow介绍 Tagline&#xff1a;An open-source software library for Machine Intelligence.Definition&#xff1a;TensorFlow TM is an open source software library fornumerical computation using data flow graphs.GitHub&#xff1a;https://github.com/tensorfl…

webbrowser设置为相应的IE版本

注册表路径&#xff1a; HKEY_LOCAL_MACHINE\SOFTWARE\WOW6432Node\Microsoft\Internet Explorer\Main\FeatureControl\FEATURE_BROWSER_EMULATION 或者HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Internet Explorer\Main\FeatureControl\FEATURE_BROWSER_EMULATION 究竟选择哪一个…