小编Ami*_*ahi的帖子

这是python-3.10中列表理解的反汇编：

Python 3.10.12 (main, Jun 11 2023, 05:26:28) [GCC 11.4.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import dis
>>> 
>>> dis.dis("[True for _ in ()]")
  1           0 LOAD_CONST               0 (<code object <listcomp> at 0x7fea68e0dc60, file "<dis>", line 1>)
              2 LOAD_CONST               1 ('<listcomp>')
              4 MAKE_FUNCTION            0
              6 LOAD_CONST               2 (())
              8 GET_ITER
             10 CALL_FUNCTION            1
             12 RETURN_VALUE

Disassembly of <code object <listcomp> at 0x7fea68e0dc60, file "<dis>", line 1>:
  1           0 BUILD_LIST               0
              2 LOAD_FAST …

我的代币发送程序遇到了发送交易的问题，抛出了下面的错误。

Error: failed to send transaction: Transaction simulation failed: Error processing Instruction 0: custom program error: 0x1

与SOL平衡有关。我想知道这个问题背后的原因。是因为发送端的SOL较少吗？或者我想知道是否是因为收件人的溶胶较少

我正在尝试获得一个非常大的数字（超过unsigned long long int）。所以我把它作为一个字符串，然后一个数字一个数字地转换成整数并使用它。

#include <stdio.h>
#include <string.h>

int main() 
{ 
    char m[100];
    int x;
    scanf("%s",m);
    for(int i=0; i<strlen(m); i++){
        sscanf(m[i],"%d",&x);
        printf("%d",x);
    }

    return 0; 
}

但是，在编译期间它显示：

警告：传递 'sscanf' 的参数 1 使指针来自整数而不进行强制转换

和

注意：预期为“const char *restrict”，但参数的类型为“char”

而且，当我运行程序时，它会给我Segmentation fault (core dumped) 错误。

我还尝试了更简单的代码来查找问题：

#include <stdio.h>
#include <string.h>

int main() 
{ 
    char m[5];
    char n;
    int x;
    scanf("%s",m);
    n = m[1];
    sscanf(n,"%d",&x);  
    return 0; 
}

但什么都没有改变。

正如我在此处阅读的那样，使用该reversed函数反转字符串比切片符号string[::-1]. 但是当我自己尝试时，我观察到了不同的结果。

首先，我试图制作一个非常大的字符串。然后我尝试检查检查大字符串中是否存在字符串需要多长时间。这就是我所做的：

In [1]: large = "abcdefgijklmnopqrstuvwxyz1234567890!@#$%^&*()_=+0}{QWERT"                                                                           

In [2]: large = 1000*large                                                                                                                           

In [3]: large = 1000*large  

In [5]: len(large)                                                                                                                                   
Out[5]: 56000000

In [6]: %time "a" in large[::-1]                                                                                                                     
CPU times: user 63 ms, sys: 43.4 ms, total: 106 ms
Wall time: 106 ms
Out[6]: True

In [7]: %time "a" in reversed(large)                                                                                                                 
CPU times: user 11 µs, sys: 1 µs, total: 12 µs
Wall time: 17.6 µs
Out[7]: True

如果我检查 , 中仅存在 1 个字符 …

不确定这是否偏离主题，但不知道有什么更好的地方可以问。其中cpython有一个非常巨大的switch case语句用于执行每个操作码。此开关盒先前已放置在_PyEval_EvalFrameDefault函数中。链接在这里。switch case 语句从这里开始。这是 cpython 的核心部分，每个对 cpython 内部结构感兴趣的人可能都会详细探索它。最近我在找它，但没有找到。在这个版本中_PyEval_EvalFrameDefault我找不到它。比上一篇短多了。我什至尝试通过在 IDE 中搜索操作码来找到此 switch 语句。但即便如此也无助于找到它在哪里。任何了解最新 cpython 开发变化的人都可以帮助我吗？提前致谢。

在 Julia shell 中，当我想计算一些大数字时，它会为其中一些返回零，而为其他人返回非零。

julia> 23^1023
-7505274568781129817

julia> 23^10233345345345345345345345
-524211381283076585

julia> 6^66
0

julia> 6^666567
0

julia> 6^666567467456456
0

为什么？据我所知，当一个数字大于它的可变容量的两倍时，它的值将为零。但它不是这样的。

据我所知，cpython 实现为某些相同的值保留相同的对象以节省内存。例如，当我创建 2 个带有 value 的字符串时hello，cpython 不会创建 2 个不同的字符串PyObject：

>>> s1 = 'hello'
>>> s2 = 'hello'
>>> s1 is s2
True

我听说过名字string interning。当我尝试用其他 python 类型检查它时，我发现几乎所有可哈希（不可变）类型都是相同的：

>>> int() is int()
True
>>> str() is str()
True
>>> frozenset() is frozenset()
True
>>> bool() is bool()
True

几乎所有可变类型都是相反的（cpythonPyObject甚至为相同的值创建一个新的类型）：

>>> list() is list()
False
>>> set() is set()
False
>>> dict() is dict()
False

我认为这是因为我们可以对PyObject不可变对象使用相同的方法而不会出现任何问题。

当我看到该float类型的行为与其他不可变类型不同时，我的问题就出现了：

>>> float() is float() …

这些是我在 中的测试结果ipython。

为了int：

In [2]: %time for _  in range(1000): exec(\'a: int = 4\')                                                                                                                         \nCPU times: user 12.2 ms, sys: 12 \xc2\xb5s, total: 12.2 ms\nWall time: 12.2 ms\n\nIn [3]: %time for _  in range(1000): exec(\'a = 4\')                                                                                                                              \nCPU times: user 9.5 ms, sys: 0 ns, total: 9.5 ms\nWall time: 9.54 ms\n\n

对于str：

In [4]: %time for _  in range(1000): exec(\'a: str = "hello"\')                                                                                                                   \nCPU times: user 13.3 ms, sys: 0 …

我尝试Chain在 Rust 中使用，遇到了一个对我来说似乎很奇怪的问题。我尝试了两个代码片段，其中一个有效，另一个无效。我试图从编译器发出的错误消息中找出问题所在，但找不到任何有用的信息。

片段1

fn main() {

    let v: Vec<_> = (1..5).collect();
    let u = v.iter().chain([6, 7, 8, 9, 10].iter().map(|i| i ));
    u.for_each(|i| println!("{i}"));
}

片段2

fn main() {

    let v: Vec<_> = (1..5).collect();
    let u = v.iter().chain([6, 7, 8, 9, 10].iter().map(|i| i+1 ));
    u.for_each(|i| println!("{i}"));
}

第一个片段成功运行，但第二个片段失败。错误信息是：

   Compiling playground v0.0.1 (/playground)
error[E0271]: type mismatch resolving `<[closure@src/main.rs:5:56: 5:63] as FnOnce<(&{integer},)>>::Output == &{integer}`
 --> src/main.rs:5:28
  |
5 |     let u = v.iter().chain([6, 7, 8, 9, 10].iter().map(|i| i+1 ));
  | …

我有 str 形式的数字列表

li = ['1', '4', '8.6']

如果我用int转换结果是[1, 4, 8]。如果我用float转换结果是[1.0, 4.0, 8.6]

我想将它们转换为[1, 4, 8.6]

我试过这个：

li = [1, 4, 8.6]
intli = list(map(lambda x: int(x),li))
floatli = list(map(lambda x: float(x),li))
print(intli)
print(floatli)

>> [1, 4, 8]
>> [1.0, 4.0, 8.6]

我同意这可能是一个非常初学者的问题，但我不知道为什么我不能使用“。” 访问对象指针的成员。

例如

JMP *sum_obj = new JMP("0");\nJMP a;\nsum_obj->number;\na.number;\n\nsum_obj.number; // error: request for member \xe2\x80\x98number\xe2\x80\x99 in \xe2\x80\x98sum_obj\xe2\x80\x99, which is of pointer type \xe2\x80\x98JMP*\xe2\x80\x99 (maybe you meant to use \xe2\x80\x98->\xe2\x80\x99 ?)\n

这里，为什么要使用->会员sum_obj number呢？

我在c中找到的函数的源代码strlen如下：

int
strlen(string)
    char *string;       /* String whose length is wanted. */
{
    register char *p = string;

    while (1) {
    if (p[0] == 0) {
        return p - string;
    }
    if (p[1] == 0) {
        return p + 1 - string;
    }
    if (p[2] == 0) {
        return p + 2 - string;
    }
    if (p[3] == 0) {
        return p + 3 - string;
    }
    p += 4;
    }
}

链接是这个。我不明白为什么步骤是 4。该函数在字符串上跳转 4 个字节乘 …

我很好奇，使用std::move将左值整数转换为右值与0向该整数添加 a 之间有什么实际区别吗？或任何其他中性算术运算（乘以1、减去0等）。

添加0：

int f(int&& i){
    i++;
    return i;
}


int main(){
    int x = 43;
    f(x+0);
}

使用std::move：

#include <iostream>

int f(int&& i){
    i++;
    return i;
}


int main(){
    int x = 43;
    f(std::move(x));
}

我知道我们不能对所有类型执行这种中立的操作，但我的问题特别是关于整数而不是其他类型。