我只是好奇**kwargs.我刚开始学习它,所以在浏览stackoverflow和视频教程的所有问题时,我注意到我们可以这样做
def print_dict(**kwargs):
print(kwargs)
print_dict(x=1,y=2,z=3)
这给出了输出:{'y': 2, 'x': 1, 'z': 3}
所以我想出为什么不反过来打印出类似的东西x=1,y=2,z=3
所以我尝试了这个:
mydict = {'x':1,'y':2,'z':3}
print(**mydict)
但我得到了一个错误:( TypeError: 'z' is an invalid keyword argument for this function有时它显示'y'是无效的关键字).
我也尝试将它分配给变量,然后打印它,但我又得到一个错误(SyntaxError: invalid syntax):
mydict = {'x':1,'y':2,'z':3}
var = **mydict
print(var)
看到这个工作:
def print_dict(**this):
print(this)
mydict = {'x':1,'y':2,'z':3}
print_dict(**mydict)
但不是print(this)如果我这样做print(**this)会给出错误.
我们可以*arg在尝试此代码时进行打印:
def num(*tuple_num):
print(tuple_num)
print(*tuple_num)
num(1,2,3,4)
它完美运行并输出如下:
(1, 2, 3, 4)
1 2 3 4
所以我想知道是否有任何可能的解决方案/打印方式**kwargs？
有没有人知道任何论文讨论内联算法？并且密切相关,父子图与调用图的关系.
背景:我编写了一个编译器,Ocaml其中积极地内联函数,主要是由于这个和其他一些优化,它为我的编程语言生成比许多其他情况(包括偶数C)更快的代码.
问题#1:算法在递归时遇到问题.为此,我的规则只是将子项内联到父项中,以防止无限递归,但这会阻止兄弟函数一次性内联.
问题2:我不知道优化内联操作的简单方法.我的算法对于函数体的可变表示是势在必行的,因为它甚至不可能实现有效的函数内联算法.如果调用图是一棵树,很明显自下而上的内联是最佳的.
技术信息:内联包含许多内联步骤.问题是步骤的顺序.
每个步骤的工作原理如下:
克隆操作使得内联递归函数变得非常困难.保持已经在进行中的列表并且只是检查我们是否已经处理此调用的常用技巧不能以天真的形式工作,因为递归调用现在被转移到调整后的代码中.函数,递归目标可能已更改为克隆的子项.但是,该子进程在调用父进程时仍在调用调用其子进程的原始父进程,现在不会停止展开递归.如上所述,我通过仅允许对孩子进行递归调用来打破此回归,从而防止内联的兄弟递归.
由于需要garbage collect使用未使用的功能,因此内联成本更加复杂.由于内联可能具有指数性,因此这是必不可少的.如果对函数的所有调用都是内联的,那么如果尚未内联函数,我们应该删除该函数,否则我们将浪费时间内联到一个不再使用的函数中.实际上跟踪谁调用极其困难的东西,因为在内联时我们不使用实际的函数表示,而是"解开"的表示:例如,正在按顺序处理指令列表并构建新列表,并且在任何一个时间点可能没有连贯的指令列表.
在他的ML编译器中,Steven Weeks选择使用多次重复应用的小优化,因为这使得优化易于编写且易于控制,但不幸的是,与递归算法相比,这错过了许多优化机会.
问题3:内联函数调用何时安全？
一般来说解释这个问题:在一个懒惰的函数式语言中,参数包含在闭包中,然后我们可以内联一个应用程序; 这是Haskell的标准模型.然而,它也解释了为什么Haskell这么慢.如果参数已知,则不需要闭包,那么参数可以直接替换其出现的参数(这是正常的顺序beta-reduction).
但是,如果已知参数评估不是非终止的,则可以使用急切评估:为参数分配表达式的值一次,然后重复使用.这两种技术的混合使用闭包但将结果缓存在闭包对象中.尽管如此,GHC还没有成功地生成非常高效的代码:显然非常困难,特别是如果你有单独的编译.
在菲利克斯,我采取了相反的方法.通过证明优化保留语义,而不是要求正确性并逐步提高效率,我要求优化定义语义.这保证了优化器的正确操作,但代价是不确定某些代码将如何表现.我们的想法是为程序员提供一些方法,以便在默认优化策略过于激进时强制优化器符合预期的语义.
例如,默认参数传递模式允许编译器选择是将参数包装在闭包中,用参数替换参数,还是将参数赋值给参数.如果程序员想要强制关闭,他们就可以传递一个闭包.如果程序员想要强制进行评估,他们会标记参数var.
这里的复杂性比函数式编程语言要大得多:Felix是一个带变量和指针的过程语言.它还有Haskell风格的类型.这使得内联例程极其复杂,例如,类型类实例尽可能替换抽象函数(由于在调用多态函数时类型特化,在内联时可能会找到一个实例,所以现在我们有了一个新函数可以内联).
为了清楚起见,我必须添加一些注释.
内联和其他一些优化,例如用户定义的术语缩减,类型类实例化,线性数据流检查变量消除,尾部rec优化,都是在给定函数上同时完成的.
排序问题不是应用不同优化的顺序,问题是订购功能.
我使用脑死算法来检测递归:我建立了每个函数直接使用的所有内容的列表,找到闭包,然后检查函数是否在结果中.请注意,在优化过程中,使用集会多次构建,这是一个严重的瓶颈.
函数是否递归可能会发生变化.尾部优化后,递归函数可能变为非递归.但是有一个更难的情况:实例化类型类"虚拟"函数可以使看似非递归的递归.
至于兄弟调用,问题是给定f和g,其中f调用g和g调用f我实际上想要将f内联到g中,并将g内联到f ..一次.我的无限回归停止规则是只允许将f内联到g如果它们是相互递归的,如果f是g的子,则不包括内联兄弟.
基本上我想"尽可能"地"平掉"所有代码.
algorithm ocaml compiler-theory compiler-optimization graph-algorithm
我想构建一个 iOS 10 应用程序，让您可以拍摄 RAW ( .dng) 图像，对其进行编辑，然后将编辑后的.dng文件保存到相机胶卷中。通过结合来自 Apple 2016 年“ AVCamManual ”和“ RawExpose ”示例应用程序的代码，我已经达到了CIFilter包含 RAW 图像和编辑的地步。
但是，我不知道如何将结果CIImage作为.dng文件保存到相机胶卷中。这可能吗？
我在python中使用二叉树.我需要创建一个方法来搜索树并返回可以插入新值的最佳节点.但是我从这个递归函数返回一个值时遇到了麻烦.我是python的新手.
def return_key(self, val, node):
if(val < node.v):
if(node.l != None):
self.return_key(val, node.l)
else:
print node.v
return node
else:
if(node.r != None):
#print node.v
self.return_key(val, node.r)
else:
print node.v
return node
打印node.v打印节点值,但是当我打印返回的节点时:
print ((tree.return_key(6, tree.getRoot().v)))
它打印
没有
结果.
我正在努力创造
[ x
for x in [1,2,3]
for y in [3,1,4] ]
输出:
[1, 1, 1, 2, 2, 2, 3, 3, 3]
但我想要的是创造
预期产出:
[1, 1, 1, 2, 3, 3, 3, 3]
是否可以在列表理解中执行此操作？
我不得不使用一种数据结构,它将元素保持在某种顺序,以便我可以查询最少元素并有效地插入新元素set ( C++ stl).所以我选择了
.这需要log(n)时间,插入和log(n)用于删除至少元件.
所以我写了以下程序:
#include<iostream>
#include<set>
#include<stdio.h>
using namespace std;
int main()
{
set<int>s1,s2;
set<int>::iterator it;
int tmp,i;
for(i=1;i<=1000000;i++)s1.insert(i);
for(i=1;i<=1000000;i++)
{
it=s1.begin();
s2.insert(*it);
s1.erase(s1.begin());
}
return 0;
}
但这需要1.67我的机器上的秒数(我的核心3)我期望更少,O(log(1000000)*1000000)即2*10^7我尝试优先级队列也给了我相同的性能.那么我应该实现自己的堆以使其更快或有其他方式吗？