对于已经分配了与名称"a"关联的DownValues的情况,是否有可接受的方法来阻止将OwnValues分配为相同的名称?(我最初在玩某人试图实现数据字典的时候遇到过这个问题.)
这就是我要避免的意思:
Remove[a];
a[1] := somethingDelayed
a[2] = somethingImmediate;
DownValues[a]
a[1]
a[2]
Run Code Online (Sandbox Code Playgroud)
返回...
{HoldPattern[a[1]] :> somethingDelayed,
HoldPattern[a[2]] :> somethingImmediate}
somethingDelayed
somethingImmediate
Run Code Online (Sandbox Code Playgroud)
现在,如果我们要评估:
a = somethingThatScrewsUpHeads;
(* OwnValues[a] above stored in OwnValues *)
a[1]
a[2]
Run Code Online (Sandbox Code Playgroud)
我们得到......
somethingThatScrewsUpHeads[1]
somethingThatScrewsUpHeads[2]
Run Code Online (Sandbox Code Playgroud)
是否有一种简单/灵活的方法来防止DownValues中任何名称的OwnValues?(Lemme猜测......这是可能的,但会有性能受损吗?)
我正在初始化很多字符串变量,如下所示:
a, b, c, d, e, f, g, h = "", "", "", "", "", "", "", ""
你可以看到这看起来不太好(更多的变量有更长的名字).有更紧凑的快捷方式吗?
在编程时我是个业余爱好者,但我正在尝试使用Python.基本上我想要做的是在字典值上使用数学.我能想到的唯一方法是将字典值分配给变量,然后将新值分配给字典.像这样的东西:
my_dictionary {
'foo' = 10,
'bar' = 20,
}
variable = my_dictionary['foo']
new_variable += variable
my_dictionary['foo'] = new_variable
Run Code Online (Sandbox Code Playgroud)
但是,当我尝试以这种方式分配变量时,我收到语法错误.有没有更好,更直接的方法来做到这一点?
编辑:另外,我只是以此为例.假设这是一段代码,而不是整个程序.新变量尚未声明的事实完全无关紧要,我只想知道如何对字典值执行数学运算.此外,我试图访问我的代码功能之外的字典.
如何转换变量赋值块,例如:
private final String s1 = "10011";
private final String s2 = "01100";
private final String ones = "11111";
private final String zeros = "00000";
Run Code Online (Sandbox Code Playgroud)
采用拉直的格式,所有=符号在最长的左侧之后与一个空格对齐,例如:
private final String s1 = "10011";
private final String s2 = "01100";
private final String ones = "11111";
private final String zeros = "00000";
Run Code Online (Sandbox Code Playgroud) 我已经学习了几个月的Python,也知道很少的C,我想知道是否有人可以为我清除这个疑问:
变量是名称,值还是内存位置?
例如:
x = 5
Run Code Online (Sandbox Code Playgroud)
是变量x,x的值,还是内存中x的位置?
我正在寻找变量是什么的明确解释.我已经查看了维基百科关于变量和这个问题的页面,但对我来说都不太清楚.如果这是一个重复的问题,那么指向正确答案的链接将非常棒.
谢谢!
我一直在寻求从我的代码中获得更多的性能; 最近,在浏览这个Python维基页面时,我发现了这个主张:
多次分配比单独分配慢.例如,"x,y = a,b"比"x = a; y = b"慢.
好奇,我测试了它(在Python 2.7上):
$ python -m timeit "x, y = 1.2, -1.4"
10000000 loops, best of 3: 0.0365 usec per loop
$ python -m timeit "x = 1.2" "y = -1.4"
10000000 loops, best of 3: 0.0542 usec per loop
Run Code Online (Sandbox Code Playgroud)
我以不同的顺序重复了几次,等等,但多重赋值片段的表现始终比个人作业至少好30%.显然,我的代码涉及变量赋值的部分不会成为任何重大瓶颈的根源,但我的好奇心仍然被激发了.当文档另有说明时,为什么多项任务明显快于个人任务?
编辑:
我测试了两个以上变量的赋值,得到了以下结果:

趋势似乎或多或少一致; 任何人都可以复制它吗?
(CPU:Intel Core i7 @ 2.20GHz)
python performance variable-assignment timeit python-internals
我正在查看一些旧的Fortran 90代码并且遇到了=>符号:
var => item
Run Code Online (Sandbox Code Playgroud)
看起来它被用于某种任务.
搜索谷歌"箭头符号Fortran"或"等于大于符号Fortran"给我没有相关材料.
我想知道我可以做什么类型的内省来检测可以通过原始内存副本分配的类型?
例如,据我所知,内置类型的内置类型元组和此类元组的元组将属于此类别.我的动机是,如果可能,我想传输原始字节.
T t1(...); // not necessarely default constructible
T t2(...);
t1 = t2; // should be equivalent to std::memcpy(&t1, &t2, sizeof(T));
// t1 is now an (independent) copy of the value of t2, for example each can go out of scope independently
Run Code Online (Sandbox Code Playgroud)
如果赋值可以(原则上)替换为?,那么在编译类型中可以告诉什么type_trait或组合?type_traitsmemcpy
我想你会为我猜应该fullfil这个条件的类型和让我吃惊的是适合的行为是不是唯一的工作,std::is_trivially_assignable但是std::trivially_destructible.这在某种程度上是有意义的,但我很困惑为什么其他一些选项不能用于预期的情况.
我知道可能没有防弹方法,因为人们总是可以编写一个有效可记忆的类,不能被"检测"为memcopyable,但我正在寻找一个适用于简单直观案例的类.
#include<type_traits>
template<class T> using trait =
std::is_trivially_destructible
// std::is_trivial
// std::is_trivially_copy_assignable
// std::is_trivially_copyable // // std::tuple<double, double> is not trivially copyable!!!
// std::is_trivially_default_constructible
// …Run Code Online (Sandbox Code Playgroud) my ($a, $b) = 33,44 # $a will be 33 and $b 44
Run Code Online (Sandbox Code Playgroud)
但是,如果您尝试在变量声明后分配值,则将以静默方式删除值
my ($a = 44, $b = 33);
say $a, $b; #OUTPUT: «(Any)(Any)?»
Run Code Online (Sandbox Code Playgroud)
从那以后它就变得更加怪异了
my ($a = 44, $b);
Run Code Online (Sandbox Code Playgroud)
失败了:
===SORRY!=== Error while compiling /tmp/G7JgLMe1Wq
Cannot put required parameter $b after optional parameters
Run Code Online (Sandbox Code Playgroud)
和
my ($a, $b = 33);
Run Code Online (Sandbox Code Playgroud)
将与将它们中的任何一个分配在一起具有相同的结果.
这种行为让我感到困惑.它应该发出警告吗?第一个表达式是否也会产生与可选参数相同的错误?我们应该将其记录为陷阱吗?上述所有的?
据我了解,变量评估是在运行时完成的。但是,类型评估是在Java中的编译时完成的。
同样,正如我所见,使变量恒定(我正在使用局部变量,但是上面的概念没有改变),将在编译时知道其值。
我提供了两个示例来测试这个概念。第一个起作用,第二个不起作用。
有人可以向我解释为什么将变量设为常量可以使我将短变量分配给int变量,而不能将int变量分配给long吗?
// Working example
final int x = 10;
short y = x;
// Non-working example
final long a = 10L;
int b = a;
Run Code Online (Sandbox Code Playgroud) python ×4
variables ×2
c++ ×1
c++11 ×1
coding-style ×1
dictionary ×1
eclipse ×1
final ×1
fortran ×1
fortran90 ×1
java ×1
key-value ×1
memcpy ×1
performance ×1
perl6 ×1
pointers ×1
raku ×1
timeit ×1
type-traits ×1