标签: mutability

两个单独创建的可变列表具有不同的 ID。

Python外壳：（可变）

>>> mylist = ['spam', 'eggs']
>>> yourlist = ['spam', 'eggs']
>>> id(mylist), id(yourlist)
(49624456, 48910408)

虽然两个单独创建的不可变字符串具有相似的 id。

Python外壳：（不可变）

>>> a = 10
>>> b = 10
>>> id(a), id(b)
(507099072, 507099072)

是a和b引用同一个对象？如果不是，为什么 id 是相似的？是mylist和yourlist引用不同的对象吗？如果是，为什么他们有不同的 id。

在Python中,globals()返回全局符号表locals()的表示,同时返回本地状态的表示.虽然两者都返回字典,但更改将globals()在全局符号表中生效,而更改locals()则无效.

为什么会这样？

我只是在python中经历可变和不可变的结构.在Python中写道"字符串是不可变的",即我们无法改变它们考虑代码:

str1='Rohit'
str1.replace('R','M')

这给出了输出:

'Mohit'

现在,有人说是变量str1指向字符串'Rohit',在str1.replace()之后它指向'Mohit'考虑以下代码:

'Rohit'.replace('R','M')

这也给了我输出:

'Mohit'

那么'字符串是不可变的'是什么意思？

最近我解决了一个涉及更新大量关键值的问题.

当然,我考虑使用a Map,操作类似Map.put/3.

然而,考虑到Elixir中数据结构的不可变性,这似乎是不够的:

iex> m = Map.put(%{}, :a, 1)
%{a: 1}
iex> Map.put(m, :b, 2)
%{a: 1, b: 2}
iex> m
%{a: 1}

然后我握住的状态解决了这个问题Map的GenServer,以及使用更新它handle_cast/3的调用.

一般来说,这是正确的方法,还是这个太多了？

我有以下Groovy脚本:

mymap = ['key': 'value']
println mymap

v = mymap.get('notexistkey', 'default')

println v
println mymap

当我运行它时,我得到以下控制台输出:

[key:value]
default
[key:value, notexistkey:default]

我很惊讶,当调用mymap.get('notexistkey', 'default')第二个参数是一个默认值时,当给定的键不存在时,该键notexistkey被添加到我称之为方法的地图上.为什么？这是预期的行为吗？我怎样才能防止这种突变？

我有这样的配置设置：

#[derive(Debug, Deserialize, Serialize)]
struct Config {
    defaults: Option<Default>,
}

#[derive(Debug, Deserialize, Serialize)]
struct Default {
    duration: Option<Millis>,
}

#[derive(Serialize, Deserialize, Debug)]
struct Millis(u64);

有一个值let cfg: &mut Config，我怎么能轻松地设置这个值的持续时间？

我试过这个，如果值不存在，它会恐慌：

*cfg.default.as_mut().unwrap().duration.as_mut().unwrap() = Millis(1234)

unwrap除了这个，我还没有找到解决这些s 的方法来按需创建值，这更加冗长......

if cfg.defaults.is_none() {
    cfg.defaults = Some(Default { duration: None });
}

if cfg.defaults.as_mut().unwrap().duration.is_none() {
    cfg.defaults.as_mut().unwrap().duration = Some(Millis(1234));
}

什么是“方法”来做到这一点？

如果我的取消引用链中有任何不可变的引用，我似乎无法改变任何东西。一个样品：

fn main() {
    let mut x = 42;
    let y: &mut i32 = &mut x; // first layer
    let z: &&mut i32 = &y; // second layer
    **z = 100; // Attempt to change `x`, gives compiler error.

    println!("Value is: {}", z);
}

我收到编译器错误：

fn main() {
    let mut x = 42;
    let y: &mut i32 = &mut x; // first layer
    let z: &&mut i32 = &y; // second layer
    **z = 100; // Attempt to …

我正在尝试链接Iterators：

var it = Iterator(1)
it.next
it = Iterator(2) ++ it
it.next
it.hasNext

hasNext正如您在此处看到的那样无限循环：https : //scastie.scala-lang.org/qbHIVfsFSNO5OYmT4pkutA

如果您运行它并在无限循环时检查堆栈，它会在内容中循环：

        at scala.collection.Iterator$ConcatIterator.merge(Iterator.scala:213)
        at scala.collection.Iterator$ConcatIterator.advance(Iterator.scala:197)
        at scala.collection.Iterator$ConcatIterator.hasNext(Iterator.scala:227)

（此堆栈来自 Scala 2.12.11，但 Scastie 链接在 中显示相同的行为2.13.2）。

我知道在调用方法之后永远不应该使用迭代器，但这似乎对我有用。使用varto 指向“当前”迭代器并将其更改为指向一个新的迭代器，该迭代器附加上一个迭代器的剩余部分。

以下稍微修改确实有效：

        at scala.collection.Iterator$ConcatIterator.merge(Iterator.scala:213)
        at scala.collection.Iterator$ConcatIterator.advance(Iterator.scala:197)
        at scala.collection.Iterator$ConcatIterator.hasNext(Iterator.scala:227)

Scastie 链接：https ://scastie.scala-lang.org/1X0jslb8T3WIFLHamspYAg

这向我表明，以某种方式损坏的版本正在创建一个附加自身的迭代器。关于这里发生了什么的任何提示？

抱歉，如果这是一个愚蠢的问题，我对 Rust 还比较陌生，只是无法破解这个双重可变借用错误。我正在尝试创建一个 AVL 树方法，该方法可以找到可以插入新节点的适当位置。我不明白我需要做什么才能放弃第一笔借款。

我试图在没有 RC、RefCell 或 Unsafe 的情况下做到这一点 - 尽管我越来越不清楚我的方法是否可行。

Rust 游乐场链接

    pub fn find_pos(&mut self, key: &K) -> &mut Link<K, V>{
        let mut current = &mut self.root;
        while let Some(node) = current.as_mut() {  // <- first mutable borrow
            match node.key.cmp(&key) {
                Ordering::Equal => break,
                Ordering::Greater => {
                    current = &mut node.right;
                },
                Ordering::Less => {
                    current = &mut node.left;
                },
            }
        };
        current  // <- second mutable borrow
    }

我也尝试过与此处描述的解决方案类似的方法，但没有成功。

    pub fn find_pos(&mut self, key: …

我从考试中得到了下面的代码,我不明白为什么你第一次做f2 = f1,做f1.set()更改f2但是之后你设置时f1 = Foo("Nine", "Ten")根本没有改变f2.如果有人知道为什么请向我解释.非常感谢!

码:

class Foo():
    def __init__(self, x=1, y=2, z=3):
        self.nums = [x, y, z]

    def __str__(self):
        return str(self.nums)

    def set(self, x):
        self.nums = x

f1 = Foo()
f2 = Foo("One", "Two")

f2 = f1
f1.set(["Four", "Five", "Six"])
print f1
print f2

f1 = Foo("Nine", "Ten")
print f1
print f2

f1.set(["Eleven", "Twelve"])
print f1
print f2

结果:

['Four', 'Five', 'Six']
['Four', 'Five', 'Six']
['Nine', 'Ten', 3] …