标签: mutability

这段代码应该打印什么？

class Parent():
    class Meta(object):
        classattr = "Hello"

class Child(Parent):
    pass


Child.Meta.classattr = "world"


ch = Child()
pr = Parent()

ch.Meta.classattr = "Oppa"

print Parent.Meta.classattr
print Child.Meta.classattr

print pr.Meta.classattr
print ch.Meta.classattr

我期待以下:

Hello
world
Hello
Oppa

但得到了

Oppa
Oppa
Oppa
Oppa

所以......我可以通过修改子类实例来修改父类(而不是实例!).这是正常的吗？

我有一个定义了成员的类：

self.myset = set()

当我执行时myobject.myset.add('item')，使用我的类的一个实例，它工作正常：print(myobject.myset)给我 {'item'} 。

但是，当我执行myobject.myset.union(yourset)， whereyourset不为空时，它将不起作用；print(myobject.myset)仍然打印为空集。为什么一种方法 ( add) 有效而另一种方法 ( )union却悄悄地（没有抛出异常）失败？即使myobject.myset = yourset有效，但union尤其不会。

我正在使用 Python 3。

引用:

如果静态final字段具有可变引用类型,则如果引用的对象是不可变的,则它仍然可以是常量字段.

我不确定这是什么意思; 有人能给出一个例子吗？

我在kata期间遇到了这个问题.我更具可读性的实现如下:

use std::vec::Vec;

fn repeat_even(v: Vec<i32>) -> Vec<i32> {
    v.into_iter().flat_map(|x| match x % 2 { 0 => vec![x, x], _ => vec![x] }).collect()
}

fn main() {
    let v = vec![1, 2, 3, 4, 6];
    assert_eq!(repeat_even(v), vec![1, 2, 2, 3, 4, 4, 6, 6]);
}

我有两个问题:

• 是否有必要创造另一个Vec？可以使用相同的Vec,即在迭代时修改它吗？

• 我认为,我的解决方案效率低下:我分配了很多向量,而且我无法保证这将得到优化.是否有更好的解决方案:可读性和分配更少？

我想将my_id，仅当存在时更改为另一个值：

fn read(id: &mut i32) {
    *id = 42;
}

struct S {
    my_id: Option<i32>,
}

impl S {
    fn run(&mut self) {
        match self.my_id {
            Some(mut id) => read(&mut id),
            _ => (),
        }
    }
}

fn main() {
    let mut s = S { my_id: 0.into() };

    s.run();

    println!("{:?}", s.my_id);
}

操场

此代码打印Some(0)，这意味着替换失败，但我不明白为什么。我是否因为模式匹配而失去了可变性？

我正在尝试通过《Common Lisp：符号计算的温和介绍》一书来学习 Common Lisp 。此外，我正在使用 SBCL、Emacs 和 Slime。

到第 10 章结束时，在高级部分有这个问题：

10.9. 编写一个破坏性函数 CHOP，将任何非 NIL 列表缩短为一个元素的列表。(CHOP '(FEE FIE FOE FUM)) 应该返回 (FEE)。

这是答题纸的解决方案：

(defun chop (x)
   (if (consp x) (setf (cdr x) nil)) 
   x)

我理解这个解决方案。但是，在查看官方解决方案之前，我尝试过：

(defun chop (xs)
  (cond ((null xs) xs)
        (t (setf xs (list (car xs))))))

使用它作为测试的全局变量：

(defparameter teste-chop '(a b c d))

我试过 REPL：

CL-USER> (chop teste-chop)
(A)

如您所见，该函数返回预期结果。

不幸的是，不会发生改变原始列表的副作用：

CL-USER> teste-chop
(A B C D)

为什么它没有改变？

由于我将整个列表的字段 (setf) 设置为仅将其汽车包装为新列表，因此我希望原始列表的 cdr …

我是 Haskell 的新手，所以如果这个问题很愚蠢，请原谅。

想象一下，我们有两个绑定到名称x和y 的数据结构。

x是可变的。

y不是。

作为一个问题或原则，x是否一定具有与y不同的类型？

我为本书第 8.3 节中的第三个建议练习编写了一个可行的解决方案，但有些行为违背了我的直觉。具体来说，我似乎能够改变一个看起来被实例化为不可变的向量。

我已经包含了我认为相关的代码部分，省略了不Vec与HashMap.

我在代码块之后进行了一些猜测，但我确实可以对实际发生的情况进行更可靠的解释。

// Start by declaring a new HashMap. This is where the mystery begins for me.
let mut departments: HashMap<String, Vec<String>> = HashMap::new();

// This code deals with getting user input from stdin and has been elided
// ...

// Match the first string slice
match args[0] {
  
  // Add an employee to a department in the HashMap
  "add" => {
    
    // POINT OF INTEREST 1
    // Adding a department that …

当我尝试使用+ =运算符修改字符串,并使用id()方法来检查对象的标识时,字符串似乎是可变的.有人面对这种奇怪的python行为吗？

a = '123'

print id(a)
# 89806008

a += '1'

print id(a)
# 89245728

a += '1'

print id(a)
# 89245728

print a

# '12311'

使用 a = a + '1'doesnt具有相同的效果,并更改字符串ID.

我是Scala世界的新手,现在我正在阅读名为"Scala in Action"的书(Nilanjan Raychaudhuri),即第97页的"可变对象需要不变"的部分,我不明白以下部分直接来自上述书籍.

假设ListBuffer是协变的,以下代码片段在没有任何编译问题的情况下工作:

scala> val mxs: ListBuffer[String] = ListBuffer("pants")
mxs: scala.collection.mutable.ListBuffer[String] =
ListBuffer(pants)
scala> val everything: ListBuffer[Any] = mxs
scala> everything += 1
res4: everything.type = ListBuffer(1, pants)

你能发现问题吗？因为所有内容都是Any类型,所以可以将整数值存储到字符串集合中.这是一场等待发生的灾难.为了避免这些问题,使可变对象不变是一个好主意.

我会有以下问题..

1)everything实际上是什么类型的？String还是Any？声明是" val everything: ListBuffer[Any]",因此我会期望Any,因为一切都应该是类型Any然后我没有看到任何问题,Integer并且String在一个ListBuffer[Any].如何将整数值存储到字符串集合中如何写？为何灾难??? 我为什么要使用List(不可变)而不是ListBuffer(可变)？我没看见有分别.我找到了很多答案,可变集合应该具有类型不变量,并且不可变集合应该具有协变类型,但为什么呢？

2)最后一部分res4: everything.type = ListBuffer(1, pants)是什么意思？"everything.type"是什么意思？我猜这里everything没有任何方法/函数或变量调用type..为什么没有ListBuffer [Any]或ListBuffer [String]？

非常感谢,

安德鲁