小编Her*_*ery的帖子

不知何故,在下面的Node类中,wordList和adjacencyList变量在Node的所有实例之间共享.

>>> class Node:
...     def __init__(self, wordList = [], adjacencyList = []):
...         self.wordList = wordList
...         self.adjacencyList = adjacencyList
... 
>>> a = Node()
>>> b = Node()
>>> a.wordList.append("hahaha")
>>> b.wordList
['hahaha']
>>> b.adjacencyList.append("hoho")
>>> a.adjacencyList
['hoho']

有没有什么方法可以继续使用默认值(在这种情况下为空列表)的构造函数参数,但要让a和b都有自己的wordList和adjacencyList变量？

我正在使用python 3.1.2.

我想知道当Web服务器将自己描述为预分叉Web服务器时它究竟意味着什么.我有一些例子,例如红宝石的独角兽和蟒蛇的gunicorn.

更具体地说,这些是问题:

• 这个模型解决了什么问题？
• 最初启动预分叉Web服务器时会发生什么？
• 它如何处理请求？

此外,一个更具体的问题为独角兽/ gunicorn:

假设我有一个我想用(g)独角兽运行的webapp.在初始化时,webapp将执行一些初始化操作(例如,填写其他数据库条目).如果我用多个worker配置(g)unicorn,初始化的东西会多次运行吗？

我正在使用http://www.json.org/java/index.html提供的JSON库将我拥有的json字符串转换为CSV.但我遇到的问题是,转换后键的顺序会丢失.

这是转换代码:

    JSONObject jo = new JSONObject(someString);
    JSONArray ja = jo.getJSONArray("items");
    String s = CDL.toString(ja);
    System.out.println(s);

这是"someString"的内容:

{
    "items":
    [
        {
            "WR":"qwe",
            "QU":"asd",
            "QA":"end",
            "WO":"hasd",
            "NO":"qwer"
        },
    ]
}

这是结果:

WO,QU,WR,QA,NO
hasd,asd,qwe,end,qwer

虽然我期望保持键的顺序:

WR,QU,QA,WO,NO
qwe,asd,end,hasd,qwer

有什么方法可以使用这个库得到这个结果吗？如果没有,是否有任何其他库可以提供保持结果中键的顺序的功能？

我正在使用JPA 2.0和hibernate.我有一个User类和一个Group类,如下所示:

public class User implements Serializable {
    @Id
    @Column(name="USER_ID")
    private String userId;

    @ManyToMany
    @JoinTable(name = "USER_GROUP",
               joinColumns = {
                   @JoinColumn(name = "GROUP_ID")
               },
               inverseJoinColumns = {
                   @JoinColumn(name = "USER_ID")
               }
    )
    private Set<Group> groupList;

    //get set methods
}

public class Group
{
    @Id
    @Column(name="GROUP_ID")
    private String groupId;

    @ManyToMany(mappedBy="groupList")
    private Set<User> memberList;
    //get set methods
}

然后,我创建一个用户和组,然后将用户分配给该组.

我想要的是当我删除该组时,该组将被删除(当然),该组所拥有的所有用户组关系将自动从USER_GROUP连接表中删除,但用户本身不会从USER表.

使用上面的代码,当我删除一个组时,只删除GROUP表中的行,并且用户仍然会在USER_GROUP连接表中有一个已删除组的条目.

如果我将Cascade放在User类中,如下所示:

@ManyToMany(cascade=CascadeType.ALL)
@JoinTable(name = "USER_GROUP",
joinColumns =
{
    @JoinColumn(name = "GROUP_ID")
},
inverseJoinColumns =
{
    @JoinColumn(name = "USER_ID")
})
private Set<Group> …

我是hibernate和spring的初学者.我已经了解了hibernate事务划分(至少我认为是这样).但在编写了一些像这样的方法之后:

sessionFactory.getCurrentSession().beginTransaction();
//do something here
sessionFactory.getCurrentSession().endTransaction();

我开始想要避免它,并希望在我的方法之外自动完成它,这样我只会写"//在这做一些事情"部分.我已经阅读了有关TransactionProxyFactoryBean的内容,并认为xml配置非常长,并且必须重复我想要进行事务处理的每个类,所以如果可能的话我想避免使用它.

我尝试使用@Transactional但它根本不起作用.我在applicationContext.xml中有这些行

<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
    <property name="dataSource" ref="dataSource" />
    <property name="configLocation" value="classpath:hibernate.cfg.xml" />
</bean>

<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
    <property name="dataSource" ref="dataSource" />
    <property name="sessionFactory" ref="sessionFactory" />
</bean>

<tx:annotation-driven transaction-manager="transactionManager" />

我已经使用@Transactional标记了我的服务类但是我总是得到"xxx在没有活动事务时无效".这是一个给我一个错误的示例代码(在单元测试btw中运行):

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations =
{
    "classpath:applicationContext.xml"
})
@TransactionConfiguration(transactionManager = "transactionManager", defaultRollback = true)
public class UserServiceTest
{
    @Resource
    private UserService userService;

    @Test
    public void testAddUser()
    {
        User us = new User();
        us.setName("any name");
        userService.addUser(us);
    }
}

在这种情况下,确切的错误消息是:"org.hibernate.HibernateException:如果没有活动事务,则保存无效".

更新:我尝试从外部单元测试(即从实际的Web应用程序)调用userService.addUser()方法,我也得到了相同的错误.

这是我的hibernate.cfg.xml:

<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration …

当我使用内容脚本将一些javascript注入HTML页面时,我遇到了javascript执行顺序的一些问题:

这是我用来测试的HTML页面,test.html:

<html><head>    
<title>Test Page</title></head>
  <body>
    <script>
      console.log("In page");
    </script>
  </body>
</html>

这是我用来向HTML页面注入额外代码的javascript :injector.js:

var s = document.createElement("script");
s.src = chrome.extension.getURL("inject.js");
document.documentElement.appendChild(s);
console.log("Inject finished");

这是注入脚本的内容,inject.js:

console.log("Inside inject.js");

最后,这是我的manifest.json:

  "web_accessible_resources": [
    "inject.js"
  ],
  "content_scripts": [
    {
      "matches": ["<all_urls>"],
      "js": ["/injector.js"],
      "run_at": "document_start"
    }
  ]

现在,当我打开test.html时,这就是我在控制台中得到的:

Inject finished
In page
Inside inject.js

我的问题是,为什么In page之前打印出来Inside inject.js？是不是inject.js应该先运行,因为我设置run_at到document_start？

如果这是设计的,有什么方法可以确保inject.js中的内容在HTML页面内的脚本之前执行而不改变HTML页面内的任何内容？

将async属性设置为false …

例如,给定一个十六进制: 83 E4 F0

通过查看英特尔开发人员的手册,我可以找出83手段and和FO手段-16.看E4,我可以解码源/目标寄存器是SP还是ESP.

因此,我可以得出结论,十六进制意味着and $-16, %ESP或者and $-16, %SP.但是,在手册中,两者都列为83 /4 ib.

我如何区分这两者？

我有一个像这样的输入字符串:a1b2c30d40我想将字符串标记为:a, 1, b, 2, c, 30, d, 40.

我知道我可以逐个读取每个字符并跟踪前一个字符以确定我是否应该对它进行标记(连续两位数表示不对其进行标记)但是有更多的pythonic方法吗？

我将有一个像"hello"world这样的字符串作为一个hashmap键.这个键实际上来自用户输入,这就是为什么有可能把这样的东西作为一个键.这样可以吗？

我有这段代码在python 2.7中正常工作."dist"是一个数字字典,"min_dist"只是一个数字.

for v in vertices:
    if dist[v.node_id] < min_dist:
        min_dist = dist[v.node_id]
        cur_min = v

现在我试图在python 3.2下运行它,它给了我这个错误:

    if dist[v.node_id] < min_dist:
TypeError: unorderable types: dict() < int()

我在python 3.2中的代码出了什么问题？

我有一个模板化的Stack类,内部使用vector实现.

这是我(简化)TStack.h的内容:

#include <vector>
#include <iostream>

template<typename T> class TStack;
template<typename T> TStack<T> operator+(const TStack<T> &s1, const TStack<T> &s2);

template<typename T>
class TStack {
    friend TStack<T> operator+<>(const TStack<T> &s1, const TStack<T> &s2);
    private:
        std::vector<T> items;
    public:
        void printAll() {
            std::cout << "The content of the stack is: ";
            typename std::vector<T>::iterator it;
            for(it = items.begin(); it < items.end(); it++) {
                std::cout << *it << " ";
            }
            std::cout << std::endl;
        }
};

template<typename T>
TStack<T> operator+(const TStack<T> &s1, const TStack<T> &s2) …