• 关于

    函数_递归

    的搜索结果

回答

如果单纯的递归一定会慢很多,因为你计算时反复计算了一些值,浪费了相当多的时间, 但是优化之后的递归和地推效率基本一样,虽然递归要进栈出栈花费时间,且容易因递归深度过大而栈溢出. 所谓的优化,就是记忆化,比如递归函数是f(a,b) 那么弄一个数组,f_r[a,b] 每次运行递归函数f(a,b)时,检测f_r[a,b]的值是否已定义,是则返回这个值,否则执行函数,且在函数返回前记录返回值到f_r[a,b]中.
沉默术士 2019-12-02 01:24:02 0 浏览量 回答数 0

问题

请问dataworks中如何定义递归函数?

我需要把Oracle中自定义递归函数转换为dataworks中的递归函数。 Oracle中的递归函数如下: CREATE FUNCTION getParentList (rootId VARCHAR (50)) RETURNS...
mujmkjtup4cgu 2020-12-21 16:18:45 44 浏览量 回答数 1

回答

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 "<"+tag+css_class+">" + 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 "<" + self._tag + self._css_class+">" + 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() 其它 关于更多的示例,你可以参看: Python Decorator Library来源:网络
51干警网 2019-12-02 01:10:47 0 浏览量 回答数 0

问题

如何将子集查找递归转换为循环?

我有一个函数,它递归地浏览一些数字列表,并找到可被某个除数整除的所有子集。有没有可能将其转换为循环解决方案的方法? def subset_sums(arr, l, r, dvr, summed &...
is大龙 2020-03-24 09:41:16 0 浏览量 回答数 1

问题

用bs4爬取标签内的text的问题

def get_coursename(info): info = get_content(url) soup = BeautifulSoup(info) all_coursename = soup.find_all('h2...
星球华人 2019-12-01 19:51:00 1215 浏览量 回答数 1

问题

用bs4爬取标签内的text的问题

def get_coursename(info): info = get_content(url) soup = BeautifulSoup(info) all_coursename = soup.find_all('h2...
杨冬芳 2019-12-01 19:52:29 867 浏览量 回答数 1

回答

我想到两件事: 1-您可以反复将表外部连接到自身,以递归地沿树走,如: SELECT * FROM MY_GROUPS MG1 ,MY_GROUPS MG2 ,MY_GROUPS MG3 ,MY_GROUPS MG4 ,MY_GROUPS MG5 ,MY_GROUP_MEMBERS MGM WHERE MG1.PARENT_ID = MG2.UNIQID (+) AND MG1.UNIQID = MGM.GROUP_ID (+) AND MG2.PARENT_ID = MG3.UNIQID (+) AND MG3.PARENT_ID = MG4.UNIQID (+) AND MG4.PARENT_ID = MG5.UNIQID (+) AND MGM.USER_ID = 9 那会给你这样的结果: UNIQID PARENT_ID NAME UNIQID_1 PARENT_ID_1 NAME_1 UNIQID_2 PARENT_ID_2 NAME_2 UNIQID_3 PARENT_ID_3 NAME_3 UNIQID_4 PARENT_ID_4 NAME_4 UNIQID_5 GROUP_ID USER_ID 4 2 Cerepedia 2 1 CATS 1 null Cerebra null null null null null null 8 4 9 此处的限制是,您必须为要沿树移动的每个“级别”添加新的联接。如果您的树少于20个级别,则可以通过创建一个显示每个用户20个级别的视图来摆脱它。 2-我知道的唯一其他方法是创建一个递归数据库函数,然后从代码中调用它。这样,您仍然会有一些查找开销(即,您的查询数量仍将等于您在树上行走的级别数量),但总体而言,它应该更快,因为它们全部在数据库中进行。 我不确定MySql,但是在Oracle中,此功能类似于此功能(您必须更改表名和字段名;我只是复制过去所做的事情): CREATE OR REPLACE FUNCTION GoUpLevel(WO_ID INTEGER, UPLEVEL INTEGER) RETURN INTEGER IS BEGIN DECLARE iResult INTEGER; iParent INTEGER; BEGIN IF UPLEVEL <= 0 THEN iResult := WO_ID; ELSE SELECT PARENT_ID INTO iParent FROM WOTREE WHERE ID = WO_ID; iResult := GoUpLevel(iParent,UPLEVEL-1); --recursive END; RETURN iResult; EXCEPTION WHEN NO_DATA_FOUND THEN RETURN NULL; END; END GoUpLevel; /
保持可爱mmm 2019-12-02 03:16:34 0 浏览量 回答数 0

回答

#include<stdio.h> #include<stdlib.h> #include<time.h> void main() { clock_t start, finish; double duration=0; int n; printf ("input the data n=:"); scanf ("%d",&n); start = clock(); fib(n); finish = clock(); duration = (double)(finish - start) / CLOCKS_PER_SEC; printf( "递归法用时=%f seconds\n", duration ); start = clock(); fic(n); finish = clock(); duration = (double)(finish - start) / CLOCKS_PER_SEC; printf( "递推法用时=%f seconds\n", duration ); } //递归法 int fib(int n) { if( n == 1 || n == 2) return 1; else return fib(n-1)+fib(n-2); } //递推法 int fic (int n) { int f0=1,f1=1,f2,i=2; if (n<2) return(n); while (i<=n) { f2=f1+f0; f0=f1,f1=f2; i++; } return f2; } 此段程序将递归法和递推法计算斐波拉契函数的时间详细计算出,可以比较两个算法的时间复杂性。显然此处递推比递归算法要好得多。 递推就是从前往后推,递归还有个回溯的过程,通过调用自身函数完成计算。
小旋风柴进 2019-12-02 01:24:50 0 浏览量 回答数 0

问题

在odps中,如何实现递归函数的功能(从节点递归查询所有父节点)

表结构:节点id、上级节点id。oracle 通过以下语句实现:select SYS_CONNECT_BY_PATH(列名,'&gt;') from 表名start wITh 列名='0000000001' connect by prio...
小流 2019-12-01 19:37:22 3553 浏览量 回答数 3

问题

编写一个递归函数matching_bracket(string,idx)以找到与string [id

尽管有很多关于stackoverflow的问题来检查字符串是否平衡,但我需要找到的右括号的索引string[idx]。例如: >>> matching_bracket('([])...
祖安文状元 2020-02-21 14:02:54 0 浏览量 回答数 1

回答

1、递归和非递归(用栈) 非递归(用栈),也用到栈函数了,和递归就没多大区别了! 每次递归进栈出栈,非递归(用栈)的每次调用栈函数也是进栈出栈。主要是在非递归(用栈)中,它的栈函数里比递归多了些赋值语句。。。所以效率上,非递归(用栈)比递归差。 只不过,递归越深,占用栈空间越多。非递归(用栈),占用的栈空间少。如果,递归的深度还没达到超出栈空间的程度,那么递归比非递归(用栈)好。 如果是非递归(不用栈),当然是非递归最好。 在下面的这个例子(解决“整数划分问题”)中,说明了如果只是用栈机械的模拟,得到的结果只是: 空间不变(事实上,非递归应该多一些),而非递归的时间数倍的增加。。 感兴趣的朋友运行就知道了 #include<iostream> #include<stack> #include<ctime> using namespace std; //---------------------------递归算法 int q(int n,int m) { if((n<1) || (m<0)) return 0; if((n==1) ||(m==1)) return 1; if(n<m) return q(n,n); if(n==m) return q(n,m-1)+1; return q(n,m-1)+q(n-m,m); } int q(int num) { return q(num,num); } struct Point { int n,m; Point(int _n,int _m){ n=_n; m=_m;} }; //-------------------------非递归算法 int _q(int n,int m) { int sum=0; Point tmp(n,m); stack<Point> s; s.push (tmp); while(!s.empty()) { tmp=s.top(); n=tmp.n; m=tmp.m; s.pop(); if((n<1) || (m<0)) ++sum; else if((n==1) ||(m==1)) ++sum; else if(n<m) s.push(Point(n,n)); else if(n==m) { ++sum; s.push(Point(n,m-1)); } else { s.push(Point(n,m-1)); s.push(Point(n-m,m)); } } return sum; } int _q(int num) { return _q(num,num); } int main() { int num; unsigned int p; do{ cout<<"Input a num:"; cin>>num; p=clock(); cout<<" 递归: "<<q(num)<<endl; cout<<"\t\t用时:"<<clock()-p<<endl; p=clock(); cout<<"非递归: "<<_q(num)<<endl; cout<<"\t\t用时:"<<clock()-p<<endl<<endl; }while(num); return 0; } 2. 如果非递归不是用栈做的 这里有一个网友做的汉诺塔问题的非递归解法 看了真让人汗颜 这样的规律都有人发现 下载地址是: http://wenku.baidu.com/view/cfd56b3610661ed9ad51f3f9.html 此算法不是用大家以前熟悉的递归算法 虽然没运行 可以猜想 这个程序的空间和时间效率毫无疑问会大幅度提高。 3. 总结: 直接引用《算法设计与分析(第二版)》里的一段话: 结构清晰,可读性强,而且容易用数学归纳法来证明算法的正确性,而且它为设计算法,调试程序带来很大方便。 然而递归算法的运行效率较低,无论是耗费的计算时间还是占用的存储空间都比非递归算法要多 仅仅是机械地模拟还不能达到减少计算时间和存储空间的目的。因此,还需要根据具体程序和特点对递归调用的工作栈进行简化,尽量减少栈的操作,压缩栈存储以达到节省计算时间和存储空间的目的。
boxti 2019-12-02 01:23:58 0 浏览量 回答数 0

回答

in_array()在多维数组上不起作用。您可以编写一个递归函数来为您做到这一点: function in_array_r($needle, $haystack, $strict = false) { foreach ($haystack as $item) { if (($strict ? $item === $needle : $item == $needle) || (is_array($item) && in_array_r($needle, $item, $strict))) { return true; } } return false; } 问题来源于stack overflow
保持可爱mmm 2020-01-16 15:43:59 0 浏览量 回答数 0

回答

Re关于PHPsdk中的listobject函数问题 如果楼主出错了,可以将错误码贴出来,看看OSS返回的错误信息,是不是有帮助。 感觉在递归遍历的时候,每次100个,20W需要递归2000次。 我看循环处理可能更好些。下面是一个python的伪代码,楼主凑合看吧。 例如:     prefix = “”     marker = ""     delimiter = ''     maxkeys = '1000' 每次拿一千个     all_object_list = []     while 1:         res = oss.get_bucket(bucket, prefix, marker, delimiter, maxkeys) //每次拿一千个         if res.status != 200: //不是200表示出错             return res         body = res.read()         (tmp_object_list, marker) = get_object_list_marker_from_xml(body) // 从返回的Body中解析出object list和next marker,并将next marker的值返给maker         all_object_list.extend(tmp_object_list)         if len(marker) == 0: //如果marker为空,表示停止循环             break //从body中解析出object list和next marker def get_object_list_marker_from_xml(body):     object_meta_list = []     next_marker = ""     hh = GetBucketXml(body) //解析body中的xml得到一个结构体,结构体中有object list,有next marker,也有是否结束的标志。都在xml中     object_meta_list = ParseToGetObjectList(hh)     if hh.is_truncated: //表明list bucket的结果没有结束,还有object         next_marker = hh.nextmarker //获得下一次的marker     return (object_meta_list, next_marker) ------------------------- 回楼主堕落了信仰的帖子 在OSS中实际只有object的概念,并没有目录的概念,所以拿到所有的object list就可以直接操作了。
wood23 2019-12-02 02:36:54 0 浏览量 回答数 0

回答

您可以使用DB2递归查询和日期函数来做到这一点: 考虑: with cte ( calendar_date, calendar_year, calendar_month_number, calendar_month_name, calendar_day_of_month, calendar_day_of_week, calendar_day_name ) as ( select calendar_date, year(calendar_date), month(calendar_date), monthname(calendar_date), dayofmonth(calendar_date), dayofweek(calendar_date), dayname(calendar_date) from (values(date('2000-01-01'))) as t(calendar_date) union all select calendar_date + 1, year(calendar_date + 1), month(calendar_date + 1), monthname(calendar_date + 1), dayofmonth(calendar_date + 1), dayofweek(calendar_date + 1), dayname(calendar_date + 1) from cte where calendar_date < date('2021-01-01') ) select * from cte 注意:我不清楚列的CALENDAR_YEAR_MONTH含义,因此我将其分开。 前10天的 DB Fiddle演示: CALENDAR_DATE | CALENDAR_YEAR | CALENDAR_MONTH_NUMBER | CALENDAR_MONTH_NAME | CALENDAR_DAY_OF_MONTH | CALENDAR_DAY_OF_WEEK | CALENDAR_DAY_NAME ------------:| ------------:| --------------------:| ------------------:| --------------------:| -------------------:| ----------------: 2000-01-01 | 2000 | 1 | 一月 1 | 7 | 星期六 2000-01-02 | 2000 | 1 | 一月 2 | 1 | 星期日 2000-01-03 | 2000 | 1 | 一月 3 | 2 | 星期一 2000-01-04 | 2000 | 1 | 一月 4 | 3 | 星期二 2000-01-05 | 2000 | 1 | 一月 5 | 4 | 星期三 2000-01-06 | 2000 | 1 | 一月 6 | 5 | 星期四 2000-01-07 | 2000 | 1 | 一月 7 | 6 | 星期五 2000-01-08 | 2000 | 1 | 一月 8 | 7 | 星期六 2000-01-09 | 2000 | 1 | 一月 9 | 1 | 星期日 2000-01-10 | 2000 | 1 | 一月 10 | 2 | 星期一
保持可爱mmm 2019-12-02 03:16:21 0 浏览量 回答数 0

回答

递归函数的另一个案例是斐波纳契数列。 斐波纳契数列:1,1,2,3,5,8,13。。。(该数列中,有n个数字,从第三个数字开始:数值 =前一个数字 + 前面一个数字) 即,n=(n-2)+(n-1) 复制代码 1 def get_num(n):#获取斐波拉契数列中第n个数字的值 2 if n==1 or n==2: 3 return 1 4 return get_num(n-1) + get_num(n-2) 5 6 #把获取的斐波拉契数字存放到列表中 7 nums=[] 8 for i in range(1,21): 9 nums.append(get_num(i))#get_num获得一个斐波拉契数字 10 11 print(nums) 复制代码 输出结果为: 1 [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765] 2 [Finished in 0.4s] 以上两个案例是递归函数的经典案例,需要记住其使用方法。注意:在实际使用中,递归函数由于消耗时间比较长(相比for循环和while循环),所以很少使用。
游客2q7uranxketok 2021-02-03 18:25:34 0 浏览量 回答数 0

回答

一、解释 递归:在调用一个函数的过程中,直接或间接地调用了函数本身这个就叫递归 注:Python在递归中没有像别的语言对递归进行优化,所以他的每一次调用都会基于上一次的调用进行,并且他设置了最大的递归数量防止递归外溢 二、实例 直接调用自己: def func(): print('from func') func() func()复制代码 间接调用自己 def foo(): print('from foo') bar() def bar(): print('from bar') foo() foo()复制代码复制代码 递归的实现: def age(n): if n == 1: return 18 return age(n-1)+2 print(age(5)) age(5)=age(4)+2 第一次进入 age(4)=age(3)+2 第二次进入 age(3)=age(2)+2 第三次进入 age(2)=age(1)+2 第四次进入 age(1)=18 第五次进入,最后判断终止条件 age(n)=age(n-1)+2 #n>1 递归终止条件 age(1)=18 #n=1 等于终止条件 复制代码三、递归的回溯与递推 递推:像上边递归实现所拆解,递归每一次都是基于上一次进行下一次的执行,这叫递推 回溯:则是在遇到终止条件,则从最后往回返一级一级的把值返回来,这叫回溯 复制代码 实例 l =[1, 2, [3, [4, 5, 6, [7, 8, [9, 10, [11, 12, 13, [14, 15,[16,[17,]],19]]]]]]] def search(l): for item in l: if type(item) is list: search(item) else: print(item) search(l) 递归算法 1、递归的定义 递归就是子程序(或函数)直接调用自己或通过一系列调用语句间接调用自己,是一种描述问题和解决问题的基本方法。 递归常与分治思想同时使用,能产生许多高校的算法。递归常用来解决结构相似的问题。所谓结构相似,是指构成原问题的子问题与原问题在结构上相似,可以用类似的方法解决。具体地,整个问题的解决,可以分为两部分:第一部分是一些特殊情况,有直接的解法;第二部分与原问题相似,但比原问题的规模小,并且依赖第一部分的结果。。实际上,递归是把一个不能或不好解决的大问题转化成一个或几个小问题,再把这些小问题进一步分解成更小的小问题,直至每个小问题都可以直接解决。因此,递归有两个基本要素: (1) 边界条件:确定递归到何时终止,也称为递归出口。 (2) 递归模式:大问题是如何分解为小问题的,也称为递归体。 递归函数只有具备了这两个要素,才能在有限次计算后得出结果。 2、递归算法实例 2.1求一个整数n的阶乘 阶乘的定义如下图: 图1 根据阶乘的递归定义,很容易就能写出求阶乘的递归算法。 def factorial(n) : if n == 1 : return 1 #递归结束 return n * factorial(n - 1) #问题规模减1,递归调用123452.2汉诺塔 汉诺塔问题是递归函数的经典应用,它来自一个古老传说:在世界刚被创建的时候有一座钻石宝塔A,其上有64个金蝶。所有碟子按从大到小的次序从塔底堆放至塔顶。紧挨着这座塔有另外两个钻石宝塔B和C。从世界创始之日起,波罗门的牧师就一直在试图把塔A上的碟子移动到C上去,其间借助于塔B的帮助。每次只能移动一个碟子,任何时候都不能把一个碟子放在比它小的碟子上面。当牧师们完成这个任务时,世界末日也就到了。 对于汉诺塔问题的求解,可以通过以下3步实现: (1)将塔A上的n -1个碟子借助C塔先移动到B塔上; (2)把塔A上剩下的一个碟子移动到塔C上; (3)将n - 1个碟子从B塔借助塔A移动到塔C上。 很显然,这是一个递归求解的过程,假设碟子数n=3时,汉诺塔问题的求解过程如下图所示: 图2 汉诺塔的递归算法(Python实现): def Hanoi(n, A, B, C) : if (n == 1) : move(A, c) #表示只有一个碟子时,直接从A塔移动到C塔 else : Hanoi(n - 1, A, C, B) #将剩下的A塔上的n-1借助C塔移动到B塔 move(A, C) #将A上最后一个直接移动到C塔上 Hanoi(n - 1, B, A, C) #将B塔上的n-1个碟子借助A塔移动到C塔 12345678递归函数的运行轨迹 借助汉诺塔这个实例,来讲解一下递归函数的运行轨迹。在递归函数中,调用函数和被调用函数都是同一个函数,需要注意的是函数的调用层次,如果把调用递归函数的主函数称为第0层,进入函数后,首次递归调用自身称为第1层调用;从第i层递归调用自身称为第i+1层。反之退出i+1层调用应该返回第i层。下图是n=3时汉诺塔算法的运行轨迹,有向弧上的数字表示递归调用和返回的执行顺序。 图3 汉诺塔的递归算法代码实现: coding=utf-8 i = 1def move(n, mfrom, mto) : global i print "第%d步:将%d号盘子从%s -> %s" %(i, n, mfrom, mto) i += 1 def hanoi(n, A, B, C) : if n == 1 : move(1, A, C) else : hanoi(n - 1, A, C, B) move(n, A, C) hanoi(n - 1, B, A, C) 程序入口 try : n = int(raw_input("please input a integer :")) print "移动步骤如下:" hanoi(n, 'A', 'B', 'C')except ValueError: print "please input a integer n(n > 0)!" 123456789101112131415161718192021222324执行结果: 结果 2.3 斐波拉契数列 斐波拉契数列,是这样的一个数列:0、1、1、2、3、5、8、13、21、……。 斐波拉契数列的核心思想是: 从第三项起,每一项都等于前两项的和,即F(N) = F(N - 1) + F(N - 2) (N >= 2) 并且规定F(0) = 0,F(1) = 1 要求:利用递归算法获得指定项的斐波拉契数列。 !/usr/bin/python coding=utf-8 def fib_list(n) : if n == 1 or n == 2 : return 1 else : m = fib_list(n - 1) + fib_list(n - 2) return m print "请输入要打印的斐波拉契数列项数n的值*"try : n = int(raw_input("enter:"))except ValueError : print "请输入一个整数!" exit()list2 = [0]tmp = 1while(tmp <= n): list2.append(fib_list(tmp)) tmp += 1print list2
xuning715 2019-12-02 01:10:16 0 浏览量 回答数 0

问题

java ssh 项目oracle移植到postgresql:报错

原来一使用ssh开发的项目,因实际需要,要从oracle迁移到postgresql。 理想 1.postgresql中创建相关表,把数据从oracle导到postgresql中 2.复制...
kun坤 2020-06-06 11:22:50 0 浏览量 回答数 1

回答

所述懒惰单行方法 如果您愿意损失一点点性能,则可以使用JSON方法在一个内衬中执行此操作(尽管有些人报告说它比递归遍历对象要快-很有可能是因为PHP 在调用函数时很慢)。“ 但是我已经做到了。”你说。不完全是-您json_decode在阵列上使用过,但需要先对其进行编码json_encode。 要求 该json_encode和json_decode方法。这些自动捆绑在PHP 5.2.0及更高版本中。如果您使用任何旧版本,则还有一个PECL库(也就是说,在这种情况下,您应该真正更新PHP安装。对5.1的支持已在2006年停止。) 转换一个array/ stdClass- >stdClass $stdClass = json_decode(json_encode($booking)); 转换一个array/ stdClass- >array 手册将第二个参数指定json_decode为: assoc 时TRUE,返回的对象将转换为关联数组。 因此,以下行将把整个对象转换为数组: $array = json_decode(json_encode($booking), true); 问题来源于stack overflow
保持可爱mmm 2020-01-16 17:12:22 0 浏览量 回答数 0

回答

要使用生成器实现自己的并发,你首先要对生成器函数和 yield 语句有深刻理解。 yield 语句会让一个生成器挂起它的执行,这样就可以编写一个调度器, 将生成器当做某种“任务”并使用任务协作切换来替换它们的执行。 要演示这种思想,考虑下面两个使用简单的 yield 语句的生成器函数: # Two simple generator functions def countdown(n): while n > 0: print('T-minus', n) yield n -= 1 print('Blastoff!') def countup(n): x = 0 while x < n: print('Counting up', x) yield x += 1 这些函数在内部使用yield语句,下面是一个实现了简单任务调度器的代码: from collections import deque class TaskScheduler: def __init__(self): self._task_queue = deque() def new_task(self, task): ''' Admit a newly started task to the scheduler ''' self._task_queue.append(task) def run(self): ''' Run until there are no more tasks ''' while self._task_queue: task = self._task_queue.popleft() try: # Run until the next yield statement next(task) self._task_queue.append(task) except StopIteration: # Generator is no longer executing pass # Example use sched = TaskScheduler() sched.new_task(countdown(10)) sched.new_task(countdown(5)) sched.new_task(countup(15)) sched.run() TaskScheduler 类在一个循环中运行生成器集合——每个都运行到碰到yield语句为止。 运行这个例子,输出如下: T-minus 10 T-minus 5 Counting up 0 T-minus 9 T-minus 4 Counting up 1 T-minus 8 T-minus 3 Counting up 2 T-minus 7 T-minus 2 ... 到此为止,我们实际上已经实现了一个“操作系统”的最小核心部分。 生成器函数就是认为,而yield语句是任务挂起的信号。 调度器循环检查任务列表直到没有任务要执行为止。 实际上,你可能想要使用生成器来实现简单的并发。 那么,在实现actor或网络服务器的时候你可以使用生成器来替代线程的使用。 下面的代码演示了使用生成器来实现一个不依赖线程的actor: from collections import deque class ActorScheduler: def __init__(self): self._actors = { } # Mapping of names to actors self._msg_queue = deque() # Message queue def new_actor(self, name, actor): ''' Admit a newly started actor to the scheduler and give it a name ''' self._msg_queue.append((actor,None)) self._actors[name] = actor def send(self, name, msg): ''' Send a message to a named actor ''' actor = self._actors.get(name) if actor: self._msg_queue.append((actor,msg)) def run(self): ''' Run as long as there are pending messages. ''' while self._msg_queue: actor, msg = self._msg_queue.popleft() try: actor.send(msg) except StopIteration: pass # Example use if __name__ == '__main__': def printer(): while True: msg = yield print('Got:', msg) def counter(sched): while True: # Receive the current count n = yield if n == 0: break # Send to the printer task sched.send('printer', n) # Send the next count to the counter task (recursive) sched.send('counter', n-1) sched = ActorScheduler() # Create the initial actors sched.new_actor('printer', printer()) sched.new_actor('counter', counter(sched)) # Send an initial message to the counter to initiate sched.send('counter', 10000) sched.run() 完全弄懂这段代码需要更深入的学习,但是关键点在于收集消息的队列。 本质上,调度器在有需要发送的消息时会一直运行着。 计数生成器会给自己发送消息并在一个递归循环中结束。 下面是一个更加高级的例子,演示了使用生成器来实现一个并发网络应用程序: from collections import deque from select import select # This class represents a generic yield event in the scheduler class YieldEvent: def handle_yield(self, sched, task): pass def handle_resume(self, sched, task): pass # Task Scheduler class Scheduler: def __init__(self): self._numtasks = 0 # Total num of tasks self._ready = deque() # Tasks ready to run self._read_waiting = {} # Tasks waiting to read self._write_waiting = {} # Tasks waiting to write # Poll for I/O events and restart waiting tasks def _iopoll(self): rset,wset,eset = select(self._read_waiting, self._write_waiting,[]) for r in rset: evt, task = self._read_waiting.pop(r) evt.handle_resume(self, task) for w in wset: evt, task = self._write_waiting.pop(w) evt.handle_resume(self, task) def new(self,task): ''' Add a newly started task to the scheduler ''' self._ready.append((task, None)) self._numtasks += 1 def add_ready(self, task, msg=None): ''' Append an already started task to the ready queue. msg is what to send into the task when it resumes. ''' self._ready.append((task, msg)) # Add a task to the reading set def _read_wait(self, fileno, evt, task): self._read_waiting[fileno] = (evt, task) # Add a task to the write set def _write_wait(self, fileno, evt, task): self._write_waiting[fileno] = (evt, task) def run(self): ''' Run the task scheduler until there are no tasks ''' while self._numtasks: if not self._ready: self._iopoll() task, msg = self._ready.popleft() try: # Run the coroutine to the next yield r = task.send(msg) if isinstance(r, YieldEvent): r.handle_yield(self, task) else: raise RuntimeError('unrecognized yield event') except StopIteration: self._numtasks -= 1 # Example implementation of coroutine-based socket I/O class ReadSocket(YieldEvent): def __init__(self, sock, nbytes): self.sock = sock self.nbytes = nbytes def handle_yield(self, sched, task): sched._read_wait(self.sock.fileno(), self, task) def handle_resume(self, sched, task): data = self.sock.recv(self.nbytes) sched.add_ready(task, data) class WriteSocket(YieldEvent): def __init__(self, sock, data): self.sock = sock self.data = data def handle_yield(self, sched, task): sched._write_wait(self.sock.fileno(), self, task) def handle_resume(self, sched, task): nsent = self.sock.send(self.data) sched.add_ready(task, nsent) class AcceptSocket(YieldEvent): def __init__(self, sock): self.sock = sock def handle_yield(self, sched, task): sched._read_wait(self.sock.fileno(), self, task) def handle_resume(self, sched, task): r = self.sock.accept() sched.add_ready(task, r) # Wrapper around a socket object for use with yield class Socket(object): def __init__(self, sock): self._sock = sock def recv(self, maxbytes): return ReadSocket(self._sock, maxbytes) def send(self, data): return WriteSocket(self._sock, data) def accept(self): return AcceptSocket(self._sock) def __getattr__(self, name): return getattr(self._sock, name) if __name__ == '__main__': from socket import socket, AF_INET, SOCK_STREAM import time # Example of a function involving generators. This should # be called using line = yield from readline(sock) def readline(sock): chars = [] while True: c = yield sock.recv(1) if not c: break chars.append(c) if c == b'\n': break return b''.join(chars) # Echo server using generators class EchoServer: def __init__(self,addr,sched): self.sched = sched sched.new(self.server_loop(addr)) def server_loop(self,addr): s = Socket(socket(AF_INET,SOCK_STREAM)) s.bind(addr) s.listen(5) while True: c,a = yield s.accept() print('Got connection from ', a) self.sched.new(self.client_handler(Socket(c))) def client_handler(self,client): while True: line = yield from readline(client) if not line: break line = b'GOT:' + line while line: nsent = yield client.send(line) line = line[nsent:] client.close() print('Client closed') sched = Scheduler() EchoServer(('',16000),sched) sched.run() 这段代码有点复杂。不过,它实现了一个小型的操作系统。 有一个就绪的任务队列,并且还有因I/O休眠的任务等待区域。 还有很多调度器负责在就绪队列和I/O等待区域之间移动任务。
哦哦喔 2020-04-17 17:23:23 0 浏览量 回答数 0

回答

Python不支持读取oss数据,因此所有调用python的 Open()、 os.path.exist() 等文件和文件夹操作的函数的代码都无法执行。如Scipy.misc.imread()、numpy.load()等。 通常采用以下两种办法在机器学习平台读取数据。 使用tf.gfile下的函数,适用于简单地读取一张图片,或者一个文本等,成员函数如下。 tf.gfile.Copy(oldpath, newpath, overwrite=False) # 拷贝文件 tf.gfile.DeleteRecursively(dirname) # 递归删除目录下所有文件 tf.gfile.Exists(filename) # 文件是否存在 tf.gfile.FastGFile(name, mode='r') # 无阻塞读取文件 tf.gfile.GFile(name, mode='r') # 读取文件 tf.gfile.Glob(filename) # 列出文件夹下所有文件, 支持pattern tf.gfile.IsDirectory(dirname) # 返回dirname是否为一个目录 tf.gfile.ListDirectory(dirname) # 列出dirname下所有文件 tf.gfile.MakeDirs(dirname) # 在dirname下创建一个文件夹, 如果父目录不存在, 会自动创建父目录. 如果 文件夹已经存在, 且文件夹可写, 会返回成功 tf.gfile.MkDir(dirname) # 在dirname处创建一个文件夹 tf.gfile.Remove(filename) # 删除filename tf.gfile.Rename(oldname, newname, overwrite=False) # 重命名 tf.gfile.Stat(dirname) # 返回目录的统计数据 tf.gfile.Walk(top, inOrder=True) # 返回目录的文件树 具体请参考tf.gfile模块。 使用tf.gfile.Glob、tf.gfile.FastGFile、 tf.WhoFileReader() 、tf.train.shuffer_batch(),适用于批量读取文件(读取文件之前需要获取文件列表,如果是批量读取,还需要创建batch)。 使用机器学习搭建深度学习实验时,通常需要在界面右侧设置读取目录、代码文件等参数。这些参数通过“—XXX”(XXX代表字符串)的形式传入,tf.flags提供了这个功能。 import tensorflow as tf FLAGS = tf.flags.FLAGS tf.flags.DEFINE_string('buckets', 'oss://{OSS Bucket}/', '训练图片所在文件夹') tf.flags.DEFINE_string('batch_size', '15', 'batch大小') files = tf.gfile.Glob(os.path.join(FLAGS.buckets,'*.jpg')) # 如我想列出buckets下所有jpg文件路径 小规模读取文件时建议使用tf.gfile.FastGfile()。 for path in files: file_content = tf.gfile.FastGFile(path, 'rb').read() # 一定记得使用rb读取, 不然很多情况下都会报错 image = tf.image.decode_jpeg(file_content, channels=3) # 本教程以JPG图片为例 大批量读取文件时建议使用tf.WhoFileReader()。 reader = tf.WholeFileReader() # 实例化一个reader fileQueue = tf.train.string_input_producer(files) # 创建一个供reader读取的队列 file_name, file_content = reader.read(fileQueue) # 使reader从队列中读取一个文件 image_content = tf.image.decode_jpeg(file_content, channels=3) # 讲读取结果解码为图片 label = XXX # 这里省略处理label的过程 batch = tf.train.shuffle_batch([label, image_content], batch_size=FLAGS.batch_size, num_threads=4, capacity=1000 + 3 * FLAGS.batch_size, min_after_dequeue=1000) sess = tf.Session() # 创建Session tf.train.start_queue_runners(sess=sess) # 重要!!! 这个函数是启动队列, 不加这句线程会一直阻塞 labels, images = sess.run(batch) # 获取结果 部分代码解释如下: tf.train.string_input_producer:把files转换成一个队列,并且需要 tf.train.start_queue_runners 来启动队列。 tf.train.shuffle_batch参数解释如下: batch_size:批处理大小。即每次运行这个batch,返回的数据个数。 num_threads:运行线程数,一般设置为4。 capacity:随机取文件范围。比如数据集有10000个数据,需要从5000个数据中随机抽取,那么capacity就设置成5000。 min_after_dequeue:维持队列的最小长度,不能大于capacity。
保持可爱mmm 2020-03-27 15:32:59 0 浏览量 回答数 0

问题

你可能不知道的 Python 技巧有哪些?

有许许多多文章写了 Python 中的许多很酷的特性,例如变量解包、偏函数、枚举可迭代对象,但是关于 Python 还有很多要讨论的话题,因此在本文中,我将尝试展示一些我知道的和在使用...
游客bnlxddh3fwntw 2020-04-13 11:34:27 33 浏览量 回答数 1

问题

动态规划的实际应用:图片压缩算法 6月15日 【今日算法】

很多时候大家觉得动态规划算法没什么实际作用。一方面是因为 LeetCode 上很多题目是简化版,只是让你求一个「最大值」,而不是真正去求最优解。另一方面可能是因为真的没有接触过实际场景中的动态规划算法。 那么&...
游客ih62co2qqq5ww 2020-06-17 02:16:53 12 浏览量 回答数 1

问题

快速排序,递归时堆栈溢出 :报错

#include<stdio.h> #include<stdlib.h> #include<time.h> #define N 1000 void quick_sort(int a[],int l...
kun坤 2020-06-14 12:17:20 0 浏览量 回答数 1

问题

快速排序,递归时堆栈溢出:配置报错 

#include<stdio.h> #include<stdlib.h> #include<time.h> #define N 1000 void quick_sort(int a[],int l...
kun坤 2020-06-02 14:30:26 0 浏览量 回答数 1

回答

你的环境中没有安装 JSON 库,导致程序退而求其次使用了这个解析库,然后触发了一些遗留 BUG。错误提示很明显是说Typecho_Json这个库找不到,仔细阅读代码就可以发现这句话应该是函数本身的一个递归遍历,应该调用的是自身。解决办法就是把这个库的所有 Typecho_Json 替换成 Json。事实上你搜索一下会发现,这个文件在早前的版本中是叫 Typecho_Json 的,只是在后来的版本中改了名字,但是内部的名字忘了改回来了而已。
蛮大人123 2019-12-02 01:44:41 0 浏览量 回答数 0

问题

快速排序,递归时堆栈溢出:服务报错

"#include<stdio.h> #include<stdlib.h> #include<time.h> #define N 1000 void quick_sort(int a[],...
montos 2020-06-03 15:41:31 3 浏览量 回答数 1

回答

对于MySQL 8+:使用递归with语法。 对于MySQL 5.x:使用内联变量,路径ID或自联接。 MySQL 8+ with recursive cte (id, name, parent_id) as ( select id, name, parent_id from products where parent_id = 19 union all select p.id, p.name, p.parent_id from products p inner join cte on p.parent_id = cte.id ) select * from cte; 中指定的值parent_id = 19应设置为id您要选择其所有后代的父级的。 MySQL 5.x 对于不支持通用表表达式的MySQL版本(最高5.7版),您可以通过以下查询来实现: select id, name, parent_id from (select * from products order by parent_id, id) products_sorted, (select @pv := '19') initialisation where find_in_set(parent_id, @pv) and length(@pv := concat(@pv, ',', id)) 这是一个小提琴。 在此,@pv := '19'应将中指定的值设置为id要选择其所有后代的父级的值。 如果父母有多个孩子,这也将起作用。但是,要求每个记录都满足条件parent_id < id,否则结果将不完整。 查询中的变量分配 该查询使用特定的MySQL语法:在执行过程中分配和修改变量。对执行顺序进行了一些假设: 该from子句首先被评估。这就是@pv初始化的地方。 where按照从from别名检索的顺序为每个记录评估该子句。因此,在这里将条件放在仅包括已将其父级标识为后代树的记录中(主要父级的所有后代都逐渐添加到中@pv)。 此where子句中的条件按顺序进行评估,一旦确定了总结果,评估就会中断。因此,第二个条件必须排在第二位,因为它将添加id到父列表,并且仅在id通过第一个条件时才应发生。length即使该pv字符串由于某种原因会产生虚假的值,也只能调用该函数以确保此条件始终为true 。 总而言之,人们可能会发现这些假设过于冒险,无法依靠。该文档警告: 您可能会得到期望的结果,但这不能保证涉及用户变量的表达式的求值顺序不确定。 因此,即使它与上面的查询一致地工作,评估顺序仍可能会更改,例如,当您添加条件或将此查询用作较大查询中的视图或子查询时。这是一个“功能”,将在将来的MySQL版本中删除: MySQL的早期版本使得可以在以外的语句中为用户变量赋值SET。MySQL 8.0支持此功能以实现向后兼容,但是在将来的MySQL版本中可能会删除该功能。 如上所述,从MySQL 8.0开始,您应该使用递归with语法。 效率 对于非常大的数据集,此解决方案可能会变慢,因为该find_in_set操作不是在列表中查找数字的最理想方法,当然,在列表大小与返回的记录数量相同数量级的列表中,查找方法肯定不是。 选择1 :with recursive,connect by 越来越多的数据库执行SQL:1999 ISO标准WITH [RECURSIVE]语法的递归查询(如Postgres的8.4+,SQL Server的2005+,DB2,甲骨文11gR2的+,SQLite的3.8.4+,火鸟2.1+,H2,的HyperSQL 2.1.0+,Teradata的,MariaDB 10.2.2+)。从8.0版开始,MySQL也支持它。有关使用的语法,请参见此答案的顶部。 一些数据库具有用于分层查找的替代非标准语法,例如Oracle,DB2,Informix,CUBRID和其他数据库CONNECT BY上可用的子句。 MySQL 5.7版不提供这种功能。如果您的数据库引擎提供了这种语法,或者您可以迁移到该语法,那么这无疑是最佳选择。如果不是,则还考虑以下替代方法。 备选方案2:路径样式标识符 如果您要分配id包含层次结构信息的值(路径),事情就会变得容易得多。例如,在您的情况下,可能如下所示: ID | NAME 19 | category1 19/1 | category2 19/1/1 | category3 19/1/1/1 | category4 然后,您select将如下所示: select id, name from products where id like '19/%' 选择3:重复的自我联接 如果您知道层次结构树的深度上限,则可以使用以下标准sql查询: select p6.parent_id as parent6_id, p5.parent_id as parent5_id, p4.parent_id as parent4_id, p3.parent_id as parent3_id, p2.parent_id as parent2_id, p1.parent_id as parent_id, p1.id as product_id, p1.name from products p1 left join products p2 on p2.id = p1.parent_id left join products p3 on p3.id = p2.parent_id left join products p4 on p4.id = p3.parent_id left join products p5 on p5.id = p4.parent_id left join products p6 on p6.id = p5.parent_id where 19 in (p1.parent_id, p2.parent_id, p3.parent_id, p4.parent_id, p5.parent_id, p6.parent_id) order by 1, 2, 3, 4, 5, 6, 7; 来源:stack overflow
保持可爱mmm 2020-05-08 10:15:00 0 浏览量 回答数 0

回答

# Filename : test.py # author by : www.runoob.com def recur_fibo(n): """递归函数 输出斐波那契数列""" if n <= 1: return n else: return(recur_fibo(n-1) + recur_fibo(n-2)) # 获取用户输入 nterms = int(input("您要输出几项? ")) # 检查输入的数字是否正确 if nterms <= 0: print("输入正数") else: print("斐波那契数列:") for i in range(nterms): print(recur_fibo(i)) 执行以上代码输出结果为: 您要输出几项? 10 斐波那契数列: 0 1 1 2 3 5 8 13 21 34
游客ejnn55cgkof5g 2020-02-14 17:37:44 0 浏览量 回答数 0

回答

安装doxygen 安装包 doxygen-1.7.4.linux.bin.tar.gz(可在官网下载) 命令: 1) tar xvfz doxygen-1.7.4.linux.bin.tar.gz 2) cd doxygen-1.7.4 3) ./configure 4) make 5) make install 安装后需留意下doxyg的路径,例如:/usr/bin/doxygen 配置Doxygen工作环境 步骤: 6) 进入项目目录(test为例说明) cd test/ 7) 生成配置文件 Doxygen –g l 默认生成的配置文件名为 "Doxyfile",也可以采用 "doxygen -g your-cfg-filename" 命令格式指定所生成的配置文件名。如无特殊需要,采用默认的配置文件名即可。 l Doxyfile 文件内容非常多,大概 1000 多行,不过其中约 4/5 都是注释,每个配置选项都有一段详细的注释。日后,如果对 Doxygen 各配置选项的意义有一定了解,可以在生成配置文件的命令中添加 "-s" 选项,生成不含注释的配置文件,操作如下:$ doxygen -s -g 3)配置文件的相应设置 ,这里已经有个模板Doxyfile(test文件夹下),可以根据需要更改相应设置 项目名称,将作为于所生成的程序文档首页标题 PROJECT_NAME = “Test 文档版本号,可对应于项目版本号,譬如 svn、cvs 所生成的项目版本号 PROJECT_NUMBER = "1.0.0 程序文档输出目录 OUTPUT_DIRECTORY = doc/ 程序文档语言环境 OUTPUT_LANGUAGE = Chinese 如果是制作 C 程序文档,该选项必须设为 YES,否则默认生成 C++ 文档格式 OPTIMIZE_OUTPUT_FOR_C = YES 对于使用 typedef 定义的结构体、枚举、联合等数据类型,只按照 typedef 定义的类型名进行文档化 TYPEDEF_HIDES_STRUCT = YES 在 C++ 程序文档中,该值可以设置为 NO,而在 C 程序文档中,由于 C 语言没有所谓的域/名字空间这样的概念,所以此处设置为 YES HIDE_SCOPE_NAMES = YES 让 doxygen 静悄悄地为你生成文档,只有出现警告或错误时,才在终端输出提示信息 QUIET = YES 只对头文件中的文档化信息生成程序文档 FILE_PATTERNS = *.h 递归遍历当前目录的子目录,寻找被文档化的程序源文件 RECURSIVE = YES 示例程序目录 EXAMPLE_PATH = example/ 示例程序的头文档 (.h 文件) 与实现文档 (.c 文件) 都作为程序文档化对象 EXAMPLE_PATTERNS = *.c \ *.h 递归遍历示例程序目录的子目录,寻找被文档化的程序源文件 EXAMPLE_RECURSIVE = YES 允许程序文档中显示本文档化的函数相互调用关系 REFERENCED_BY_RELATION = YES REFERENCES_RELATION = YES REFERENCES_LINK_SOURCE = YES 不生成 latex 格式的程序文档 GENERATE_LATEX = NO 在程序文档中允许以图例形式显示函数调用关系,前提是你已经安装了 graphviz 软件包 HAVE_DOT = YES CALL_GRAPH = YES CALLER_GRAPH = YES #让doxygen从配置文件所在的文件夹开始,递归地搜索所有的子目录及源文件 RECURSIVE = YES #在最后生成的文档中,把所有的源代码包含在其中 SOURCE BROWSER = YES $这会在HTML文档中,添加一个侧边栏,并以树状结构显示包、类、接口等的关系 GENERATE TREEVIEW = ALL 程序源码文档化 准备好 Doxygen 的工作环境后,就需要根据 Doxygen 所定义的注释规则,对程序源码进行文档化。换句话说,就是在对程序源码添加注释时,要按照 Doxygen 的游戏规则来搞。 Doxygen 的注释类型可分为: l 行间注释:注释语句不与程序源码出现在同一行,主要用于注释头文件中出现的结构体 (struct)、枚举 (enum)、联合 (uion) 等数据类型,以及程序接口的功能与使用约定; l 行内注释:注释语句与程序源码出现在同一行内,主要用于代码的局部注释。 注释的种类有很多,下面是其中的一种: Doxygen 认可的行间注释标记见下例: /** 这是行间注释标记示例 */ Doxygen 认可的行内注释标记见下例: typedef struct { double coord[3]; /// 这是行内注释示例 }M2_3D_Point; 程序文档生成 现在开始生成程序文档,将终端的工作目录定位在 test 目录,然后键入: $ doxygen your-cfg-filename your-cfg-filename 是 Doxygen 配置文件名,如果是使用 "doxygen -g" 生成的配置文件——Doxyfile,那么可以在终端里仅键入 "doxygen" 命令即可生成程序文档。 生成的文档位于 test/doc/html 目录中,使用浏览器打开该目录中的 index.html 文件,即可看到自己的工作成果。 Doygen 集成到codeBlocks 5.1 配置步骤 在codeBlocks工作界面中,Tools->Configure tools ->Add Name :doxygen Executable:/usr/bin/doxygen Parameters:配置文件名,(如果doxygen –g 生成的默认配置文件,在这里不需要写) Working directory:test(要生成程序文档的项目路径) 5.2 使用: 当需要生成程序文档时:Tools->doxygen 即可。生成的文档位于 test/doc/html 目录中,使用浏览器打开该目录中的 index.html 文件,即可看到自己的工作成果
问问小秘 2019-12-02 02:09:46 0 浏览量 回答数 0

问题

归并排序 7月15日 【今日算法】

今天分享的的内容涉及以下两个问题: 归并排序的迭代实现方式;实现一个原地归并排序(In-Place Merge Sort); 归并排序的迭代实现 在正式看代码前&#...
游客ih62co2qqq5ww 2020-07-16 07:43:30 7 浏览量 回答数 1

云产品推荐

上海奇点人才服务相关的云产品 小程序定制 上海微企信息技术相关的云产品 国内短信套餐包 ECS云服务器安全配置相关的云产品 开发者问答 阿里云建站 自然场景识别相关的云产品 万网 小程序开发制作 视频内容分析 视频集锦 代理记账服务 阿里云AIoT