我正在尝试使用一个方法来实现一个类，该方法使用一个对象调用另一个方法，该对象是该类的一部分，其中最低的方法会改变该对象。我的实现有点复杂，所以我将发布一些虚拟代码，以便您可以看到我在说什么：
class test:
def __init__(self,list):
self.obj = list
def mult(self, x, n):
x = x*n
def numtimes(self, n):
self.mult(self.obj, n)
现在，如果我创建这种类型的对象并运行 numtimes 方法，它不会更新 self.obj：
m = test([1,2,3,4])
m.numtimes(3)
m.obj #returns [1,2,3,4]
而我希望它给我 [1,2,3,4,1,2,3,4,1,2,3,4]
基本上，我需要将 self.obj 传递给 mult 方法并让它改变 self.obj ，这样当我调用 m.obj 时，我会得到 [1,2,3,4,1,2,3,4, 1,2,3,4] 而不是 [1,2,3,4]。
我觉得这只是理解 python 如何将对象作为参数传递给方法的问题（就像它制作对象的副本，而我需要使用指针），但也许不是。我是 python 新手，在这里确实需要一些帮助。
提前致谢！！
我希望使用 Data.Vector.Generic.Mutable.new 创建一个可变向量。我找到了通过解冻纯向量来创建可变向量的示例，但这不是我想要做的。
这是许多失败的尝试之一：
import Control.Monad.Primitive
import qualified Data.Vector.Generic.Mutable as GM
main = do
v <- (GM.new 10) :: (GM.MVector v a) => IO (v RealWorld a)
GM.write v 0 (3::Int)
x <- GM.read v 0
putStrLn $ show x
给我错误
No instance for (GM.MVector v0 Int)
arising from an expression type signature
Possible fix: add an instance declaration for (GM.MVector v0 Int)
我尝试了基于 Haskell Vector 教程的变体，但没有成功。
我也欢迎关于构建向量的更清洁方法的建议。对现实世界的提及对我来说似乎很难看。
所以我有一个列表[a,b,c]并且我想获取[a,b,c,a,b,c,...a,b,c].
我当然可以用两个嵌套循环来做到这一点，但一定有更好的方法吗？itertools.cycle()如果我能提供一个计数，这将是解决方案。
两个限制：
如果默认情况下对象是可变的，为什么在这种情况下它不起作用？如何制作对象“s”中键“a”的变异值？
var s = {
a: "my string"
};
s.a[0] = "9"; // mutation
console.log(s.a); // doesn't work如何返回位于不可变引用后面的可变引用，作为参数传递给函数，如何处理？
struct Foo { i: i32 }
struct Bar<'b> {
f: &'b mut Foo
}
impl<'a: 'b, 'b> Bar<'b> {
fn func(&'a self) -> &'b mut Foo {
self.f
}
}
fn main() {
let mut foo = Foo { i: 1 };
let bar = Bar { f: &mut foo };
bar.func();
}
给出以下错误：
struct Foo { i: i32 }
struct Bar<'b> {
f: &'b mut Foo
}
impl<'a: 'b, 'b> Bar<'b> {
fn func(&'a self) -> &'b mut …我正在阅读《Rust 编程语言》。文档将 a 定义String为“可增长”：
UTF-8 编码的可增长字符串。
我发现可增长与可变不同，但它们并没有真正解释什么使类型“可增长”。
鉴于这种let mut guess = String::new()，
mut改变可增长的字符串？我正在阅读Ivan ?uki 的C++ 函数式编程？，我很难解释第 5 章总结中的一点：
- 当您创建成员函数时
const，您承诺该函数不会更改类中的任何数据（对象的任何部分都不会更改），或者对对象（声明为 的成员mutable）的任何更改都将是原子的作为对象的用户而言。
如果部分斜体简单地被限制在声明成员为mutable我会很高兴吧。然而，我的这种改写似乎与作者在括号中的内容一致。括号外是什么让我感到困惑：那句话中原子的含义是什么？
尝试在安全的 Rust 中创建可变迭代器时，我遇到了生命周期问题。
这是我将问题简化为：
struct DataStruct<T> {
inner: Box<[T]>,
}
pub struct IterMut<'a, T> {
obj: &'a mut DataStruct<T>,
cursor: usize,
}
impl<T> DataStruct<T> {
fn iter_mut(&mut self) -> IterMut<T> {
IterMut { obj: self, cursor: 0 }
}
}
impl<'a, T> Iterator for IterMut<'a, T> {
type Item = &'a mut T;
fn next(&mut self) -> Option<Self::Item> {
let i = f(self.cursor);
self.cursor += 1;
self.obj.inner.get_mut(i)
}
}
fn f(i: usize) -> usize {
// some permutation of i …有人可以显示mutable关键字用法的实例,当它在const函数中使用时,在实例中解释关于mutable和const函数以及volatile成员和函数的差异.
我的地图看起来像这样:Map[ A -> Collection[B]].这个地图在一个循环中得到更新 - 然而,特殊的是,更新主要只是意味着将一个元素B添加到Collection [B](对于某些键A).
我试图通过将我的Collection的类型从List []更改为ListBuffer []来查明是否可以获得一些加速.
到目前为止,我的代码看起来像这样(简化):
var incoming = new HashMap[A, List[B]() {
override def default(a: A) = List()
}
..
for(b < someCollectionOfBs){
..
incoming(b.getA) = b :: incoming(b.getA)
..
}
这很好用.现在,我改变了地图的类型,使它看起来像这样:
var incoming = new collection.mutable.HashMap[A, ListBuffer[B]() {
override def default(a: A) = collection.mutable.ListBuffer()
}
..
for(b < someCollectionOfBs){
..
incoming(b.getA) += b
..
}
请注意第二个示例中元素B如何添加到集合中的更改(不再是不可变列表,因此我们不需要创建和分配新集合...).
但是.这不起作用:incoming(X) += ..没有没有更新地图为X的值,其实它并没有改变任何东西.
我在这里错过了什么？我认为我应该能够更新可变HashMap的值...所以,如果我的值是可变集合,为什么我不能只添加元素？