小编PJ.*_*des的帖子

我想为内置list类型添加一些属性,所以我写了这个:

class MyList(list):
    def __new__(cls, *args, **kwargs):
        obj = super(MyList, cls).__new__(cls, *args, **kwargs)
        obj.append('FirstMen')
        return obj

    def __init__(self, *args, **kwargs):
        self.name = 'Westeros'

    def king(self):
        print 'IronThrone'

if __name__ == '__main__':
    my_list = MyList([1, 2, 3, 4])
    print my_list

但my_list只包含元素'FirstMen'.为什么我的__new__不在这里工作？我应该如何从内置类型继承list？对于不可变类型是否相同str？

对于此目录层次结构:

.
??? hello
?   ??? __init__.py
?   ??? world
?       ??? __init__.py
??? test.py

和Python源文件:

test.py:

if __name__ == '__main__':
    import hello

你好/ __ init__.py:

import world

你好/世界/ __ init__.py:

print("yes you win")

用Python 3.4运行test.py会ImportError说world找不到模块,但是使用Python 2.7一切都很好.

我知道sys.path在搜索导入的模块时会引用它,因此添加目录hello可以sys.path消除错误.

但是在Python 2.7中,在导入之前world,目录hello不在sys.path其中.是什么导致这种差异？是否在Python 2.7中应用了递归搜索策略？

在Computer Systems:A Programmer's Perspective一书中,练习5.5显示了一段代码来计算多项式的值

double poly(double a[], double x, int degree)
{
    long int i;
    double result = a[0];
    double xpwr = x;
    for (i = 1; i <= degree; i++) {
        result += a[i] * xpwr;
        xpwr = x * xpwr;
    }
    return result;
}

练习假设双精度浮点加法和乘法所需的时钟周期分别为3和5.要求读者解释为什么测量的CPE(每元素周期数)值为5.

按照习题答案,在每次迭代中,我们需要更新变量xpwr和result我们需要的,操作是一个浮点加法(对于result)和浮点乘法(对于xpwr),因此后者占主导地位的延迟,导致最终CPE为5.

但我认为数据流应该是这样的:

xpwr               result
  |                  |
  +-----+ +--[load]  |
  |     | |          |
[mul]  [mul]         |
  |      |           |
  |      +---+ +-----+ …

我想实现一个符号类型,它跟踪我们已经拥有的符号(保存在其中_sym_table),如果它们存在则返回它们,否则创建新符号.代码:

# -*- coding: utf-8 -*-

_sym_table = {}

class Symbol(object):
    def __new__(cls, sym):
        if sym not in _sym_table:
            return super().__new__(cls)
        else:
            return _sym_table[sym]

    def __init__(self, sym):
        self.sym = sym
        _sym_table[sym] = self

    def __str__(self):
        return self.sym

    def __cmp__(self, other):
        return self is other

    def __hash__(self):
        return self.sym.__hash__()

但是当我调用copy.deepcopy这样的Symbol实例列表时,会引发异常:

a = Symbol('a')
b = Symbol('b')
s = [a, b]
t = copy.deepcopy(s)

错误消息:

Traceback (most recent call last):
  File "xxx.py", line 7, in <module> …

在UNIX环境中的高级编程(第2版)一书中,作者在第5.5节(标准I/O库的流操作)中写道:

打开文件进行读写(类型中的加号)时,以下限制适用.

• 输出不能直接跟随输入而没有中间fflush,fseek,fsetpos,或rewind.
• 输入不能直接跟随输出而没有中间fseek,fsetpos或rewind,或输入其遇到文件结束操作.

我对此感到困惑.谁能解释一下这个呢？例如,在什么情况下输入和输出函数调用违反上述限制会导致程序出现意外行为？我想这些限制的原因可能与库中的缓冲有关,但我不太清楚.

我通过Homebrew安装了GDB 7.8.1和GCC 4.9.

当我打开由GCC编译的(gcc-4.9 -g xxx.c -o xxx)程序生成的核心文件时,它会报告:

?  gdb ./list_test /cores/core.1176
GNU gdb (GDB) 7.8.1
Copyright (C) 2014 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.  Type "show copying"
and "show warranty" for details.
This GDB was configured as "x86_64-apple-darwin14.0.0".
Type "show configuration" for configuration details.
For bug reporting instructions, …

在 SICP 第 4 章中，通过将语法分析与执行分离来修改元循环求值器，使过程eval如下所示：

(define (eval exp env)
    ((analyze exp) env))

书上说这将节省工作，因为analyze将在表达式上调用一次，而执行过程可能会被调用多次。

我的问题是，这种优化是如何进行的？它适用于递归过程调用，但其他情况又如何呢？求值器逐个求值表达式，eval即使它们具有相同的形式，仍将在每个表达式上调用。

我正在学习std::forward.我写了一个简短的程序来测试如果我们std::forward在将参数转发给另一个函数调用之前没有调用会发生什么:

#include <iostream>
#include <typeinfo>
#include <string>
using namespace std;

class Example {
};

ostream &operator << (ostream &os, const Example &e) { os << "yes!"; return os; }

void test_forward_inner(const Example &e) { cout << "& " << e << endl; }
void test_forward_inner(Example &&e) { cout << "&& " << e << endl; }

void test_forward_inner(const string &e) { cout << "& " << e << endl; }
void test_forward_inner(string &&e) { cout << …

在使用scikit-learn训练SVM分类器之后,我需要alpha值,这是SVM双重问题的拉格朗日乘数.根据该文件,似乎scikit-learn仅提供svm.dual_coef_,这是拉格朗日乘数α和数据点标签的乘积.

我试图通过除以svm.dual_coef_数据标签的元素手动计算alpha值,但由于svm.dual_coef_只存储支持向量的系数,我不确定是否迭代这个数组,支持向量的顺序是相同的作为原始训练数据中的顺序.

那么有一种可靠的方法来获得支持向量的alpha值吗？

在下面的宏定义中,在真正的粘贴操作之前有两个间接级别:

#define MACRO_JOIN(a, b)  MACRO_JOIN1(a, b)
#define MACRO_JOIN1(a, b) MACRO_JOIN2(a, b)
#define MACRO_JOIN2(a, b) a##b

我知道我们需要MACRO_JOIN1它,因为它没有粘贴或字符串化,所以它的参数可以先扩展.

但第二个间接的目的到底是什么MACRO_JOIN？什么情况MACRO_JOIN会起作用但MACRO_JOIN1会失败？

这是我的app.yaml:

- url: /about|/about/.*
  script: about.py

这是我的'about.py':

application = webapp.WSGIApplication([(r'^/about$', AboutPage),
                                      (r'^/about/$', Redirect),
                                      (r'.*', ErrorPage)],
                                        debug = True)

我想将所有请求重定向/about/到/about.我希望将所有其他请求发送到错误页面.

它在localhost上的开发服务器上工作,但我/about/在GAE上部署应用程序后无法访问- 它只显示一个空页面.

我在app.yaml中调整了URL模式的顺序.它现在适用于GAE.

假设我正在编写一个简单的解析器.它有一个调度程序,它根据输入表达式的类型调用相应的解析函数.

def dispatcher(expression):
    m = pattern1.match(expression):
    if m is not None:
        handle_type1(expression, m)
    # ... other types

我的问题是,无论如何要结合匹配和检查None？我的意思是,类似于以下C代码:

void dispatcher(char *expression)
{
    if ((m = pattern1.match(expression)) != NULL) {
        // ... handle expression type 1
    }
    else if ((m = pattern2.match(expression)) != NULL) {
        // ... handle expression type 2
    }
    // ... other cases
}

谢谢!