小编Sch*_*ote的帖子

标题有点难以理解,但我的问题很简单.

我有一个程序需要采取sqrt()一些东西,但这是我唯一需要的东西math.导入整个模块以获取单个函数似乎有点浪费.

我可以说from math import sqrt,但是然后sqrt()会被添加到我的程序的主命名空间中,我不希望这样(特别是因为我打算将程序改为可用作模块;这样导入会导致那种情况出现问题吗？).有没有办法在保留math.sqrt()语法的同时只导入那个函数？

我在这个特定情况下使用的是Python 2.7,但是如果对Python 3有不同的答案,我也希望听到它以供将来参考.

以下代码:

class queuenode {
public:
    queuenode();
    queuenode(cargo *mydata);
    ~queuenode() {delete cargo;} //Queuenodes delete their cargo on destruction - note that queuenodes DON'T free their neighbour, that's up to the queue class
public:
    queuenode *next;
    int pri; //this should always be equal to our cargo's pri
    cargo *data;
};

queuenode::queuenode(void) {
    next= (queuenode *) NULL; 
    cargo = (cargo *) NULL; //default const creates a null queuenode - pri is left undefined
}

queuenode::queuenode(cargo *mydata) {
    //Convert constr creates a queuenode wrapping …

我正在编写一个专为键盘导航界面设计的 UI 库。它有一个功能，当最终用户按下箭头键时，它可以自动“自动完成”确定突出显示从任何给定按钮移动到哪个按钮的链接。显然，这个系统需要知道图书馆用户是否已经指定了链接应该去哪里，或者当按下箭头键时是否指定了新的行为。

我想我可以只拥有On{Up/Down/Left/Right}ArrowKeyPressed方法，其默认值是将高亮切换到self.{Up/Down/Left/Right}Link，因此如果self.___Link == None并且On____ArrowKeyPressed没有被覆盖，库可以安全地假设它负责为该按钮设置该链接。

是否有可靠的方法来检测对象是否使用其默认超类方法？将thebutton.OnUpArrowKeyPressed is Button.OnUpArrowKeyPressed在所有情况下工作吗？

我有一个相当粗略的代码,必须或多或少随机生成一堆百分比,存储为十进制浮点数.也就是说,它决定材料一个占总数的13.307%,然后将其存储在dict中为0.13307.

麻烦的是,我永远无法将这些数字加起来只有一个.老实说,我不完全确定问题是什么.这可能与浮子的性质有关.

这是令人讨厌的代码,在其所有过于复杂的荣耀中:

while not sum(atmosphere.values())>=1:
    #Choose a material randomly
    themat=random.choice(list(materials.values()))

    #If the randomly chosen material is gaseous at our predicted temperature...
    if themat.vapor < temp:
        #Choose a random percentage that it will make up of our planet's atmosphere, then put it in the atmos dict.
        atmosphere[themat]=round(random.uniform(0.001,0.5),5)

#Find out if the fractions add up to more than 1
difference=(sum(atmosphere.values())-1)
#If one does...
while difference > 0:
    #Choose a random constituent
    themat=random.choice(list(atmosphere.keys()))
    #If that constituent has a higher fraction value than …

对于家庭作业,我被要求创建一个递归函数,该函数接受一个int和一个int指针,并打印第一个int的二进制表示,并将指针的目标与二进制中的一个数留下.

它适用于某些值 - 65和99工作 - 但不适用于大多数其他(负面问题在问题域之外).我不知道为什么.

void binaryPrinter(int value, int *numberOfOnes)
{
    int thisbit;

    //printf("Value is %i",value);

    if (value <= 0) { 
        printf("%i",value);
        return;
    } else if (value == 1){
        printf("1");
        *numberOfOnes = *numberOfOnes + 1;
        return;
    }


    thisbit = value % 2;
    if (thisbit) { *numberOfOnes = *numberOfOnes + 1; }
    printf("%i",thisbit);
    binaryPrinter(value / 2, numberOfOnes);
}

为什么？

我正在努力让我的游戏项目不能像1995年那样保存在自己的目录中.

标准库不合作.

基本上,我试图保存%appdata%\MYGAMENAME\(这是win32上的_savedir的值.)open()如果这样的文件夹不存在将变得可以理解,所以我用os.path.exists()它来检查它是否确实存在并创建它,如果它不存在.

麻烦的是,os.path.exists()返回True,但我可以查看文件夹并确认它没有.如果我在REPL中尝试它也不会返回True; 只在这里(我已经确认我的调试器确实如此).

酸洗步骤似乎正常进行; 它会else:立即跳到该条款.但我可以通过OS文件系统浏览器和REPL确认文件夹和文件都不存在!

这是完整的功能源(不要笑!):

def save(self):
        "Save the game."
        #Eh, ____ it, just pickle gamestate. What could go wrong?
        save_path=os.path.join(_savedir,"save.sav")
        temporary_save_path=os.path.join(_savedir,"new_save.sav")
        #Basically, we save to a temporary save, then if we succeed we copy it over the old one.
        #If anything goes wrong, we just give up and the old save is untouched. Either way we delete the temp save.
        if not os.path.exists(_savedir):
            print("Creating",_savedir)
            os.makedirs(_savedir)
        else: …

我是一名经验丰富的程序员,但只有高级语言; 我正在用C++做我的第一个非常大的项目.

我有两节课,ClassA而且ClassB; a ClassA(除其他外)是索引ClassBs,因此ClassA需要知道ClassB从中构建数组是什么,并且ClassB需要知道什么ClassA是,所以当事情发生变化时它可以更新索引.这两个类都在他们自己的.h和.cpp文件中.

我认为从另一个中包含每个只会导致无限递归,所以我决定改为拥有#include "ClassA.cpp"并且#include "ClassB.cpp"在开始时main.cpp; 但这样做只会导致编译器警告这些文件中每个类和方法的多个定义.

经过一些实验,我发现包含ClassA.h并ClassB.h产生了所需的行为 - 但这没有任何意义,我只包括那些类的原型.当然,实际上使它们成立的代码永远不会混杂在一起？然而它确实如此.

这里发生了什么,我不明白？为什么包含ClassA.h也会使实际代码ClassA显示出来？为什么包括ClassA.cpp导致每个包含ClassA.h触发"多重定义"错误,即使它们在头部屏蔽或其他任何名称？

我正在编写一个专门的单元测试工具，需要保存测试结果以便将来进行比较。因此，我需要能够一致地将传递给每个测试的参数映射到使用每个版本的这些参数运行测试函数的测试结果。我希望有一种方法可以对元组进行散列并使用该散列来命名存储测试结果的文件。

我的第一个冲动只是调用hash()参数元组，但是这当然行不通，因为hash现在在解释器实例之间是随机的。

我很难想出一种适用于元组中可能存在的任意元素的方法（我想将其限制为整数、浮点数、字符串和这三个元素的列表\元组的混合就可以了） 。有任何想法吗？

我想过使用repr元组的或对其进行酸洗，但 repr 不能保证为相同的输入产生逐字节相同的输出，而且我认为酸洗也不是（是吗？）

我已经看到了这一点，但答案都是基于相同的假设，该假设不再成立，并且无论如何也不会真正转化为这个问题，很多讨论都是关于使哈希不依赖于订单项出现，我确实希望哈希取决于顺序。

在我写的Python游戏中,我有两个类; ShipType和Ship.Ship对象代表具有自己的名称,年龄,库存等的特定宇宙飞船...... ShipType对象代表船舶的"线"(如马自达Protege是汽车的"线"),具有自己的名称,基础该类船舶的统计数据,Kelley Bluebook In Space价格等

Ship的构造函数将ShipType作为参数,因为所有Ship-s都应从ShipType派生.该构造函数如下所示:

...
def __init__(self,theshiptype):
    if not isinstance(theshiptype,ShipType):
        raise TypeError
    self.name=theshiptype.name
    self.inventory=Inventory(theshiptype.invslots)
    self.maxhp=theshiptype.maxhp
    self.thrust=theshiptype.thrust
    self.ftlspeed=theshiptype.ftlspeed
    ...

正如您所看到的,此构造函数中发生的大部分内容只是将传递对象的相同命名属性复制到self.我想知道的是,有更短的方法吗？

值得注意的是ShipType上有一些不应该在Ship上的属性.

我有一个AI例程,可以将各种数据存储为Memory对象.Memory对象具有不同的参数,这些参数基于它们传递给构造函数的"内存类型"(回想起来,每种类型的内存确实应该是它的子类Memory,但目前并不重要).

我需要__str__()为Memory-s 设置一个方法.在另一种语言中,我可能会这样做:

if self.memtype == "Price":
    return self.good+" is worth "+self.price+" at "+self.location
elif self.memtype == "Wormhole":
    return self.fromsys+" has a wormhole to "+self.tosys
...

但Pythonic(和快速)做这种事情的方法是使用dicts.但问题是,这些字符串需要在返回之前插入值.我想这可以用lambdas来完成,但这让我觉得有点不雅和过于复杂.有没有更好的方法(str.format()突然想到......)？

所以,假设我有一个任意长的数字列表.我想获得该列表中每个数字的列表乘以该列表中的每个数字.我通过嵌套这样的for循环来做到这一点:

for x in numbers:
    for y in numbers:
        print(x*y)

现在,如果我想将该列表中的每个数字相乘,该列表中的每个数字都会再次对该列表中的每个数字进行计时,我会这样做:

for x in numbers:
    for y in numbers:
        for z in numbers:
            print(x*y*z)

我的问题是我正在搜索子图的图形,我需要允许任意大的子图.为此,我必须构造每个具有来自主图中边缘的n个边的子图 - 我必须允许n的任意值.怎么样？

我是一名自学成才的程序员,第一次参加正式的大学程序设计课程.今天有人问C++课程的讲师->操作员做了什么.

教官说,沿着"箭头操作线的东西,除了用于动态分配的对象点运算符是等效的.你只能使用在静态分配对象点运算符[随后声明变量的一个例子,在一个块的开始],你只能使用箭头操作符动态分配你制作的对象new."

C++绝对不是我的专业领域......但是我所看到的所有其他事情a->b都完全相同*a.b,并且它主要是出于遗留原因而存在,因为变量在早期版本的C++中的工作方式不同.

是否真的->不能用于指向堆栈上分配的对象的指针,并且.不能用于指向堆上分配的对象的解引用指针？

我正在用Python编写一个空间交易游戏，并且我决定将地图分成较小的块，以减少在任何给定时间在屏幕上绘制时需要考虑的对象数量。

这通过具有一个Sector对象来处理，该对象的定义如下：

class Sector:
   x=0     #Position of the sector. The galactic (absolute) position of any object is its in-sector position
   y=0     #plus the galactic position offset times the size of a sector. 
   stardict=dict()

然后，生成器代码将75个星标填充到每个扇区（此刻目前为100个扇区），并保留在stardict中。

thesector=Sector()

size=size/2

#Generate stars
for t in range(stars):
    #name="Star "+str(t)
    name=generate_name().capitalize()
    thesector.stardict[name]=Star( name, (random.randint(-size,size), random.randint(-size,size)), (random.randint(0,255), random.randint(0,255), random.randint(0,255)), random.randint(3,7))

    if math.floor((t/stars)*100)==(t/stars)*100: print("Generating stars: "+str((t/stars)*100)+"% done.")

但是，在尝试实际运行程序时会出现一些奇怪的错误，并且使用调试器打开它可以说明原因：每个扇区的stardict属性是相同的，它们每个都包含完全相同的星号（不是重复的，它们具有相同的内存地址） 。据我所知，每个Sector.stardict实际上都引用同一个dict对象。

我不知道为什么会这样。谁能对此有所启发？