小编jed*_*rds的帖子

错误说:

AttributeError: 'list' object has no attribute 'cost' 

我正在尝试使用以下类来处理自行车字典的简单利润计算:

class Bike(object):
    def __init__(self, name, weight, cost):
        self.name = name
        self.weight = weight
        self.cost = cost

bikes = {
    # Bike designed for children"
    "Trike": ["Trike", 20, 100],
    # Bike designed for everyone"
    "Kruzer": ["Kruzer", 50, 165]
    }

当我尝试用my语句计算利润时,我得到属性错误.

# Markup of 20% on all sales
margin = .2
# Revenue minus cost after sale
for bike in bikes.values():
    profit = bike.cost * margin

首先,我不知道为什么它指的是列表,一切似乎都被定义了,不是吗？

这可能比"自定义标签完成"有更好的名称,但这是场景:

通常,当我在命令行并输入命令,然后输入{TAB}两次时,我会获得当前目录中所有文件和子目录的列表.例如:

[user@host tmp]$ cat <TAB><TAB>
chromatron2.exe                  Fedora-16-i686-Live-Desktop.iso  isolate.py
favicon.ico                      foo.exe                          James_Gosling_Interview.mp3

但是,我注意到至少有一个程序以某种方式过滤了这个列表:wine.考虑:

[user@host tmp]$ wine <TAB><TAB>
chromatron2.exe  foo.exe

它有效地过滤了结果*.exe.

认为它可能是负责过滤的某种包装脚本,a a which和filea结果wine不是脚本而是可执行文件.

现在,我不知道这个"过滤器"是否以某种方式编码在程序本身中,或者在默认的wine安装过程中以其他方式指定,所以我不确定这个问题是否更适合stackoverflow或超级用户,所以我是我的手指交叉扔在这里.如果我猜错了,我道歉.(另外,我检查了一些类似的问题,但大多数都是无关紧要的,或者涉及编辑shell配置.)

所以我的问题是,这个"过滤"是如何完成的？提前致谢.

请考虑以下大纲:

class Base { /* ... */ };

class Derived : public Base
{
public:
    void AdditionalFunctionality(int i){ /* ... */ }
};

typedef std::shared_ptr<Base> pBase;
typedef std::shared_ptr<Derived> pDerived;

int main(void)
{
    std::vector<pBase> v;
    v.push_back(pBase(new Derived()));

    pDerived p1(  std::dynamic_pointer_cast<Derived>(v[0])  ); /* Copy */
    pDerived p2 = std::dynamic_pointer_cast<Derived>(v[0]);    /* Assignment */

    p1->AdditionalFunctionality(1);
    p2->AdditionalFunctionality(2);

    /* A */

    return 0;
}

这里我用扩展功能(AdditionalFunctionality方法)的派生类扩展基类.

第一个问题,这样可以吗？我已经阅读了很多问题,说这不合适,你应该在基类中声明附加功能(通常建议在基类中使它们成为纯虚方法).但是,我不想这样做.我想扩展基类的功能,而不仅仅是以不同的方式实现它.有没有更好的解决方案来实现这一目标？

好的,所以在这段代码中我也使用一个STL容器来存储这些指针,这些指针允许我存储指向Base类型对象的指针以及Derived类型的对象而不切片对象.

第二个问题,这是有道理的,对吗？事实上,我通过使用指向基类对象的指针而不是基类对象本身来避免切片？

如果我"知道"某个指针指向Derived对象,那么我将使用它std::dynamic_pointer_cast来转换智能指针.

第三个问题,这个编译没有任何警告和工作,但它是否安全？有效？它是否会打破共享指针的引用计数方面,并且在我预期之前无法访问delete我的对象或delete它们？

最后,我可以使用复制构造函数或通过赋值执行此转换,如p1和p2所示.这样做是否有首选/正确的方法？

类似的问题:

• 将shared_ptr <Base>向下转换为shared_ptr <Derived>？:这是非常接近的,但是这个类没有像我一样增加额外的功能,所以我不确定它是完全一样的.此外,它使用 …

我编写了一个foreach接受lambda函数ala的函数:

void foreach(void (*p)(pNode))
{ /* ... */ }

如果我从主循环传递lambda函数,它的工作原理如下:

int a = 5;
env.N().foreach
(
    [&](pNode n)->void
    {
        n->tps(a); 
    }
);

但是,如果我尝试从成员方法中调用相同的函数,则lambda函数"继承"成员函数的范围并生成编译器错误.例如,如果我尝试将其包含在Object名为的类的成员方法中method(),我会收到以下错误:

error: no matching function for call to ‘IDSet<Node>::foreach(Object::method()::<lambda(pNode)>)’
note: candidate is: void IDSet<T>::foreach(void (*)(IDSet<T>::pT)) [with T = Node, IDSet<T>::pT = pNode]

我意识到这是编译器是安全的,因为我可以在lambda函数中包含特定于实例的变量,在这种情况下lambda需要作用域,但是我想知道是否可以使这个lambda"静态".

我试过了reinterpret_cast,但是这给了我这个错误:

error: invalid cast from type ‘Object::method()::<lambda(pNode)>’ to type ‘void (*)(pNode)’

static之前指定[&](pNode ...似乎也不是有效的语法.

拼命,我也试着更改[&]到[=],[],[a],其中没有工作.

有没有人知道是否有办法完成我创建"静态"lambda函数的目标,或者是否可以接受任何类型的lambda函数？

谢谢! …

我有一个tkinter脚本.我想知道无论如何都是这样,当你点击按钮它会带你到一个网站

from tkinter import *
app = Tk()
app.geometry("250x400")
app.title("Links")

def Link():
    ?

button1 = Button(app, text = "To a web site.", command = Link)
button1.pack()

app.mainloop()

我正在寻找一种方法来创建映射到混合类型的HashMap.

例如,以下内容适用于Python(请注意,Python dict类似于Java HashMap):

d = dict()
d["str"] = "This is a string"
d["flt"] = 1.23
d["int"] = 5

并且在访问时d[x],将返回适当的类型(在此示例中为string,float,int).

在Java中,我可以使用a HashMap<String, Object>,但我真的没有办法立即告诉每个Object的类型.

所以相反,我现在要做的是创建一个MixedType包含对象的类,还有它的原始类型信息,以便我可以在以后将其转发.例如:

public class MixedMap
    public static class MixedType
    {
        public Class<?> cls;
        public Object val;

        public MixedType(Class<?> c, Object v)
        {
            this.cls = c;
            this.val = v;
        }
    }

    public static void main(String args[])
    {   
        MixedType m1 = new MixedType(String.class, "This is a String");
        System.out.println((m1.cls)m1.val);
    }
}

请注意,这是我正在尝试做的事情:-)因为它目前没有编译抱怨 …

我大概知道这个不能回答,但是我正在寻找是否有某种是否直接使用私有成员的指导或类方法中的公共访问器.

例如,考虑以下代码(在Java中,但在C++中看起来非常相似):

public class Matrix {

    // Private Members
    private int[][] e;
    private int numRows;
    private int numCols;

    // Accessors
    public int rows(){ return this.numRows; }
    public int cols(){ return this.numCols; }

    // Class Methods
    // ...
    public void printDimensions()
    {
        // [A] Using private members
        System.out.format("Matrix[%d*%d]\n", this.numRows, this.numCols);


        // [B] Using accessors
        System.out.format("Matrix[%d*%d]\n", this.rows(), this.cols());
    }

该printDimensions()函数说明了两种获取相同信息的方法,[A]使用私有成员(this.numRows, this.numCols)或[B]通过访问者(this.rows(), this.cols()).

一方面,您可能更喜欢使用访问器,因为您无法无意中更改私有成员变量的值.另一方面,您可能更喜欢直接访问私有成员,希望它可以删除不必要的函数调用.

我想我的问题是,要么是事实上的标准还是首选标准？

考虑这个演示程序:

#include <stdio.h>

class Base
{
public:
    virtual int f(int) =0;
    virtual int f(){ return f(0); }

    virtual ~Base(){ }
};

class Derived : public Base
{
public:
    int f(int i)
    {
        return (10 + i);
    }
};

int main(void)
{
    Derived obj;
    printf("%d\n", obj.f(1));  // This works, and returns 11
    printf("%d\n", obj.f());   // Adding this line gives me the error listed below
}

这给了我以下编译错误:

virtualfunc.cpp: In function ‘int main()’:
virtualfunc.cpp:25:26: error: no matching function for call to ‘Derived::f()’
virtualfunc.cpp:15:9: …

>>> from weakref import WeakValueDictionary
>>> class Foo(object):
...     pass
>>> foo = Foo()
>>> db = WeakValueDictionary()
>>> db['foo-id'] = foo
>>> del foo
>>> dict(db)
{'foo-id': <__main__.Foo object at 0x4dd946c>}

为什么它显示这个而不是空字典？请注意,此代码生成我期望的结果:

>>> db2 = WeakValueDictionary()
>>> db2['disposable-id'] = Foo()
>>> dict(db2)
{}

执行脚本(而不是交互式解释器)时,它的行为也符合预期:

from weakref import WeakValueDictionary
class Foo(object):
    pass
foo = Foo()
db = WeakValueDictionary()
db['foo-id'] = foo
del foo
print str(dict(foo))
# prints {}

好的,请考虑以下课程:

class Object
{
public:
    // Constructor
    Object() : 
        [Initialization List]
    {
        ...
    }
    ...
};

class Container
{
public:
    Object A;
    Object B;

    ....

    Container() :
        [Initialization List]
    {
    }
};

我想向对象提供[访问Container及其成员].

我的第一个想法是以某种方式将对当前Container对象的引用传递给Objects的构造函数.但我无法弄清楚如何做到这一点.

我已经搞乱了"这个",但我没有得到任何有效的东西.我试过这样的事情:

class Object
{
public:
    Container& c

    // Constructor
    Object(Container& c_) : 
        c(c_)
    {
        ...
    }
    ...
};

class Container
{
public:
    Object A;
    Object B;

    ....

    Container() :
        A(Object(this))
        B(Object(this))
    {
    }
};

我最终的目标是能够从对象A的成员方法中访问对象B.

有没有人对如何更接近我正在寻找的东西有任何见解？

谢谢!