小编por*_*uod的帖子

我想用Cython访问的一些标准C库有很多标志.Cython文档声明我必须复制我需要的标题部分.在功能定义方面哪个很好.它们通常在任何地方都被复制,包括文档.但那些神奇的数字呢？

如果我想调用mmap,我总能找到函数定义并将其粘贴到.pxd文件中:

void *mmap(void *start, size_t length, int prot, int flags, int fd, off_t offset)

但是召唤它需要大量的旗帜PROT_READ,MAP_ANONYMOUS等等.我至少有两个问题:

首先,确切地追捕这些数字的位置是令人讨厌的工作.实际上我宁愿写一个.c文件并打印我需要的值.有没有更好的方法来找到给定旗帜的价值,如PROT_READ？

其次,这些数字有多稳定？已经提取我所需要的所有值和硬编码他们到我用Cython源,什么是编译在不同的平台的周围切换的机会,让我们说PROT_READ和PROT_EXEC？

即使答案是没有好的或正确的方法,我也想听听.只要我知道我没有遗漏某些东西,我总能接受一些繁琐的东西.

我有一个继承自字典的类,以便添加一些自定义行为 - 在这种情况下,它将每个键和值传递给一个函数进行验证.在下面的示例中,"验证"只是打印一条消息.

字典的分配按预期工作,每当项目添加到字典时打印消息.但是当我尝试使用自定义字典类型作为__dict__类的属性时,属性赋值又将键/值放入我的自定义字典类中,以某种方式设法在完全绕过时将值插入字典中__setitem__(以及其他方法我已定义可能添加密钥).

自定义词典:

from collections import MutableMapping
class ValidatedDict(dict):
    """A dictionary that passes each value it ends up storing through
    a given validator function.
    """
    def __init__(self, validator, *args, **kwargs):
        self.__validator = validator
        self.update(*args, **kwargs)
    def __setitem__(self, key, value):
        self.__validator(value)
        self.__validator(key)
        dict.__setitem__(self, key, value)
    def copy(self): pass # snipped
    def fromkeys(validator, seq, v = None): pass # snipped
    setdefault = MutableMapping.setdefault
    update = MutableMapping.update

def Validator(i): print "Validating:", i

使用它作为__dict__类的属性产生我不理解的行为.

>>> d …

我喜欢使用语言中内置的结构来组织我的代码.但有一种情况我不能保持一致,仅仅是因为我没有看到明确的最佳方式.它是关于支持类,即由另一个类在内部专门使用的类:我是将它们作为内部类还是单独的类.

内部课程:

class Complicated:
    class Utility1:
        pass
    class Utility2:
        pass
    pass

单独的课程:

class Complicated:
    pass

class Utility1:
    pass

class Utility2:
    pass

内部类具有在使用它们的唯一类中作用域的优点.但问题是由于缩进,我得到的代码空间更少.

外课没有优势也没有劣势.每当我写支持课时,我都厌倦了总是花费精力,想知道这个愚蠢的问题.

我的问题是,任何拥有丰富python经验的人是否可以建议是否有最佳实践？即使答案是"它取决于",如果它有一个比我更有经验的人,我们将不胜感激.

我经常看到python代码采用默认参数,并且在未指定时具有特殊行为.

如果我想要这样的行为:

def getwrap(dict, key, default = ??):
    if ???: # default is specified
        return dict.get(key, default)
    else:
        return dict[key]

如果我要自己动手,我最终会得到类似的东西:

class Ham:
    __secret = object()
    def Cheese(self, key, default = __secret):
        if default is self.__secret:
            return self.dict.get(key, default)
        else:
            return self.dict[key]

但是当我确实有一个标准时,我不想发明一些愚蠢的东西.在Python中这样做的惯用方法是什么？

如果std::abs(angle)存在,则以下代码不编译.angle在这种情况下的类型是a short int.

template <class T>
typename T::storage_t::single_t FastSin(const typename T::storage_t::double_t &angle) {
  const int B = (sizeof(typename T::storage_t::single_t)*8) - 2;
  return (angle<<1) - ((angle*(std::abs(angle)))>>B);
}

仔细查看消息可以验证angle实际上是一个消息short int.但是,如果我正确读取错误,GCC会将其变为a double.

math.hpp: In function ‘typename T::storage_t::single_t FastSin(const typename T::storage_t::double_t&) [with T = Fixed<_t<signed char, short int> >, typename T::storage_t::single_t = signed char, typename T::storage_t::double_t = short int]’:
vector.hpp:106:30:   instantiated from ‘void Vector2<T>::FastRotate(const single_t&) [with T = Fixed<_t<signed char, short int> >, Vector2<T>::single_t …

通过以下指令表手册阅读,我发现整数乘法通常要快得多8-bit registers.

在普通桌面CPU的上下文中,8-bit register意味着什么？存储在32位寄存器中的值是否恰好在8位范围内？没有实际的8位寄存器,对吗？

其中大部分是样板文件,作为可编译示例提供.向下滚动.

use std::rc::{Rc, Weak};
use std::cell::RefCell;
use std::any::{Any, AnyRefExt};

struct Shared {
    example: int,
}

struct Widget {
    parent: Option<Weak<Box<Widget>>>,
    specific: RefCell<Box<Any>>,
    shared: RefCell<Shared>,
}

impl Widget {
    fn new(specific: Box<Any>, 
           parent: Option<Rc<Box<Widget>>>) -> Rc<Box<Widget>> { 
        let parent_option = match parent {
            Some(parent) => Some(parent.downgrade()),
            None => None,
        };
        let shared = Shared{pos: 10};
        Rc::new(box Widget{
            parent: parent_option,
            specific: RefCell::new(specific),
            shared: RefCell::new(shared)})
    }
}

struct Woo {
    foo: int,
}

impl Woo {
    fn new() -> Box<Any> {
        box Woo{foo: …

我有一张地图,我们称之为M,其中包含通过N维映射的数据.

# If it was a 2d map, I could iterate it thusly:
start, size = (10, 10), (3, 3)
for x in range(start[0], start[0]+size[0]):
    for y in range(start[1], start[1]+size[1]):
        M.get((x, y))
# A 3d map would add a for z in ... and access it thusly
M.get((x, y, z))
# And so on.

我的问题是:如何创建一个可以产生正确迭代序列的迭代器？也就是说,鉴于start, size = (10, 10), (3, 3)它会产生2元组序列(10, 10), (10, 11), (10, 12), (11, 10), (11, 11)等.并且鉴于start, size = (10, 10, 10), …