小编Ray*_*ger的帖子

我想知道如何创建宽容字典(如果引发KeyError则返回默认值).

在下面的代码示例中,我将得到一个KeyError; 例如

a = {'one':1,'two':2}
print a['three']

为了不得到一个我将1.必须捕获异常或使用获取.

我不想用我的字典那样做...

我正在尝试使用该inspect模块,但似乎我不能在内置(本机？)类中使用它,否则我误解了.

我正在使用Python 2.7并尝试使用Python 3.2.

这是有效的:

>>> import inspect
>>> class C:
...     def __init__(self,a,b=4):
...         self.sum = a + b
... 
>>> inspect.getargspec(C.__init__)
ArgSpec(args=['self','a', 'b'], varargs=None, keywords=None, defaults=(4,))

这不起作用:

>>> import inspect
>>> import ast
>>> inspect.getargspec(ast.If.__init__)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/inspect.py", line 813, in getargspec
    raise TypeError('{!r} is not a Python function'.format(func))
TypeError: <slot wrapper '__init__' of '_ast.AST' objects> is not a Python function

我想知道是否有另一种技术可以自动获取这些参数？

(在我的例子中,我想到了一个解析Python语法的替代方案,ASDL文件解释了如何使用我在PyPy Project的源代码中看到的代码来初始化AST节点,但我想知道是否还有其他方法)

我将Python对象定义为"在任何深度都是不可变的"iff

1. 它(名义上)是不可改变的; 和
2. 如果它是一个"容器"对象,那么它只包含"在任何深度都是不可变的"对象;

例如((1, 2), (3, 4)),在任何深度都是不可变的,而((1, 2), [3, 4])不是(尽管后者,由于是一个元组,"名义上"是不可变的).

有没有合理的方法来测试Python对象是否"在任何深度都是不可变的"？

测试第一个条件相对容易(例如使用collections.Hashable类,忽略了不正确实现__hash__方法的可能性),但第二个条件更难以测试,因为"容器"对象的异质性,以及迭代他们的"内容"......

谢谢!

其实,我不完全理解的使用SETF在defun定义:

(defun cookies-out* (&optional (reply *reply*))
"Returns an alist of the outgoing cookies associated with the REPLY object REPLY."
    (cookies-out reply))

(defun (setf cookies-out*) (new-value &optional (reply *reply*))
"Sets the alist of the outgoing cookies associated with the REPLY object REPLY."
    (setf (cookies-out reply) new-value))

我想它重新定义了''cookies-out*函数,不是吗？如果是这样,那么#'cookies-out*将是一个多态函数.

祝商祺!

我有一个Python模块,我正在使用Sphinx编写教程,包括doctests.

这个模块附带了一些帮助程序.

我想在文档中包含这些帮助程序,并让doctest检查标准输出是否在当前程序版本和文档之间同步.

我想我可以使用sh模块或popen来检查给定程序的标准输出,但我更喜欢那些技巧不会显示在文档中,否则非程序员用户肯定会丢失.

有没有办法实现这一目标？

如何在Python中统一以下列表:

all_the_ways = [(5,), (2, 2, 1), (2, 1, 2), (2, 1, 1, 1), (1, 2, 2),\
                (1, 2, 1, 1), (1, 1, 2, 1), (1, 1, 1, 2), (1, 1, 1, 1, 1)]

期望的输出是:

[(5,), (2, 2, 1), (2, 1, 1, 1), (1, 1, 1, 1, 1)]

即我需要摆脱具有相同数字但不同顺序的元组.

我试过了

set(all_the_ways)

但它只转置元素.

而当我这样做

list(map(set, all_the_ways))

事情变得更糟:

[{5}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1}]

换句话说,我需要将内部元组转换为允许多个相等项(不适合)的集合,set并且元素的排列不会改变集合本身(有点像C++的multiset …

它基本上返回了box_needed.1个盒子可以包含10个项目.因此,如果用户键入的项目为102,则代码应返回11个框.

如果存在非零余数,是否有办法将该轮向上划分？

我有一个~50GB的csv文件,我必须这样做

• 获取CSV列的几个子集
• 将不同的格式字符串规范应用于CSV的每个列子集.
• 使用自己的格式规范为每个子集输出新的CSV.

我选择使用Pandas,并且有一种通用的方法来迭代一个方便的块大小(超过五十万行)的块来生成一个DataFrame,并将块附加到每个输出CSV.所以像这样:

_chunk_size = 630100

column_mapping = {
    'first_output_specification' : ['Scen', 'MS', 'Time', 'CCF2', 'ESW10'],
    # ..... similar mappings for rest of output specifications
}
union_of_used_cols = ['Scen', 'MS', 'Time', 'CCF1', 'CCF2', 'VS', 'ESW 0.00397', 'ESW0.08',
                    'ESW0.25', 'ESW1', 'ESW 2', 'ESW3', 'ESW 5', 'ESW7', 'ESW 10', 'ESW12',
                    'ESW 15', 'ESW18', 'ESW 20', 'ESW22', 'ESW 25', 'ESW30', 'ESW 35', 
                    'ESW40']

chnk_iter = pd.read_csv('my_big_csv.csv', header=0, index_col=False,
                        iterator=True, na_filter=False, usecols=union_of_used_cols)

cnt = 0
while cnt < 100:
    chnk = chnk_iter.get_chunk(_chunk_size) …

我想知道如何在fork()中发生copy-on-write.

假设我们有一个具有动态int数组的进程A:

int *array = malloc(1000000*sizeof(int));

数组中的元素初始化为一些有意义的值.然后,我们使用fork()创建一个子进程,即B.B将迭代数组并进行一些计算:

for(a in array){
    a = a+1;
}

1. 我知道B不会立即复制整个数组,但是什么时候子B为数组分配内存？在fork()期间？
2. 它是一次性分配整个数组,还是只分配一个整数a = a+1？
3. a = a+1;这是怎么发生的？B是否从A读取数据并将新数据写入其自己的数组？

我写了一些代码来探索COW如何工作.我的环境:ubuntu 14.04,gcc4.8.2

#include <stdlib.h>
#include <stdio.h>
#include <sys/sysinfo.h>

void printMemStat(){
    struct sysinfo si;
    sysinfo(&si);
    printf("===\n");
    printf("Total: %llu\n", si.totalram);
    printf("Free: %llu\n", si.freeram);
}

int main(){
    long len = 200000000;
    long *array = malloc(len*sizeof(long));
    long i = 0;
    for(; i<len; i++){
        array[i] = i;
    }

    printMemStat();
    if(fork()==0){
        /*child*/
        printMemStat();

        i = 0;
        for(; i<len/2; i++){
            array[i] = i+1; …

可以在Python中"填充"一个数组,如下所示:

> [0] * 10
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

我想使用此示例原则快速创建类似对象的列表:

> a = [{'key': 'value'}] * 3
> a
[{'key': 'value'}, {'key': 'value'}, {'key': 'value'}]

但看起来这些对象是相互关联的:

> a[0]['key'] = 'another value'
> a
[{'key': 'another value'}, {'key': 'another value'}, {'key': 'another value'}]

鉴于Python没有clone()方法(这是我寻找的第一件事),如何创建唯一对象而不需要声明for循环并调用append()添加它们？

谢谢!