我正在学习并发性,并希望澄清我对Rust书中以下代码示例的理解.如果我错了,请纠正我.
use std::sync::{Arc, Mutex};
use std::thread;
use std::time::Duration;
fn main() {
let data = Arc::new(Mutex::new(vec![1, 2, 3]));
for i in 0..3 {
let data = data.clone();
thread::spawn(move || {
let mut data = data.lock().unwrap();
data[0] += i;
});
}
thread::sleep(Duration::from_millis(50));
}
线路上发生了let data = data.clone()什么？
Rust书说
我们
clone()用来创建一个新拥有的句柄.然后将此句柄移动到新线程中.
什么是新的"拥有的手柄"？这听起来像是对数据的引用？
由于clonea &self和a 返回一个Self,是每个线程修改原始数据而不是副本？我猜这就是为什么代码没有使用data.copy()但data.clone()在这里.
在data右侧是一个参考,而data左边是一个拥有价值.这里有一个变量阴影.
在R中,当想要在另一个函数中使用一个/多个函数时,可能有两种方法.示例函数可以是:
方法1:
make.power <- function(n) {
pow <- function(x) {
x^n
}
pow
}
方法2:
make.power <- function(n) {
pow(n)
}
pow <- function(x) {
x^n
}
在我看来(但我不确定),第二种方法是一种更好的方法,如果你有很多子功能.
我的问题是: 1)这两种方式之间是否存在功能差异？例如,函数如何传递变量,或者子函数与父函数之间的关系等.
2)对于R,哪一个可能是优选的(可能更有计算效率或结构清晰)？
我想使用 Python 3 读取每行由换行符 ('\n') 指示的 csv 文件。这是我的代码：
import csv
with open(input_data.csv, newline ='\n') as f:
csvread = csv.reader(f)
batch_data = [line for line in csvread]
上面的代码给出了错误：
batch_data = [line for line in csvread].
_csv.Error: new-line character seen in unquoted field - do you need to open the file in universal-newline mode?
阅读这些帖子：CSV new-line character seen in unquoted field error，也尝试了我能想到的这些替代方案：
with open(input_data.csv, 'rU', newline ='\n') as f:
csvread = csv.reader(f)
batch_data = [line for line in csvread]
with …在实现特征时,我们经常使用关键字self,样本如下.我想了解self此代码示例中许多用法的表示.
struct Circle {
x: f64,
y: f64,
radius: f64,
}
trait HasArea {
fn area(&self) -> f64; // first self: &self is equivalent to &HasArea
}
impl HasArea for Circle {
fn area(&self) -> f64 { //second self: &self is equivalent to &Circle
std::f64::consts::PI * (self.radius * self.radius) // third:self
}
}
我的理解是:
self:&self相当于&HasArea.self:&self相当于&Circle.self三个代表Circle？如果是这样,如果self.radius使用了两次,会导致移动问题吗？此外, …
在使用Shunting-yard算法将中缀表达式转换为后缀表达式的上下文中.我想使用向量来存储输出,它将存储运算符和数值类型数据.
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum Operator {
Add,
Sub,
Mul,
Div,
}
fn main() {
let mut output: Vec<String> = Vec::new(); // create an output vector
let a = 2;
let b = Operator::Add;
let c = 3;
output.push(a.to_string());
output.push(b.to_string());
output.push(c.to_string());
}
上面的代码当然不能编译,因为to_string()没有定义方法Operator.我看到两种解决方法:
to_string()方法Operator.我认为第二个是首选,但我不知道创建引用向量是否会引入很多复杂性.
拉斯特,为了改变一个可变变量的值,是什么在差let x = 12或x = 12在以下示例代码？
fn main() {
let mut x: i32 = 8;
{
println!("{}", x);
let x = 12; // what if change to x = 12
println!("{}", x);
}
println!("{}", x);
let x = 42;
println!("{}", x);
}
输出是8, 12, 8, 42.如果我let x = 12改为x = 12......
fn main() {
let mut x: i32 = 8;
{
println!("{}", x);
x = 12;
println!("{}", x);
}
println!("{}", …我在目录中有一个文件 7.csv：~/Documents/Jane/analyst/test/1/。我能够使用 pandas.read_csv 函数读取这个文件，没有问题。
f_path = '~/Documents/Jane/analyst/test/1/7.csv'
pd.read_csv(f_path, index_col=None, header=0)
但是当使用 os.path.isfile() 检查此文件是否存在时，结果返回 False。
os.path.isfile(f_path)
False
可能的错误来源是什么？
为了在阻止移动时匹配结构,我想使用引用来进行匹配.所以下面的代码将完成这项工作:
struct Foo(i32);
fn main() {
let x = Foo(1);
match &x {
ref a => println!("hello"),
}
println!("{}", x.0);
}
但我很惊讶地发现以下代码也有效,它实际上将struct(x)与reference(ref a)匹配.但是,这不应该是类型不匹配吗？
struct Foo(i32);
fn main() {
let x = Foo(1);
match x {
ref a => println!("hello")
}
println!("{}", x.0);
}
基于在模式匹配期间防止移动语义,我的理解是当我match对结构进行操作时,如果不使用引用来进行匹配,则结构将被移动,因为它不是基本类型.为了测试这个,我实现了以下内容:
struct Point {
x: i32,
y: i32,
}
let origin = Point { x: 0, y: 0 };
match origin {
Point { x: x1, y: y1 } => println!("({},{})", x1, y1),
}
// to check if the origin has been moved, and it seems not, why ??
match origin {
Point { x: x1, y: y1 } => println!("({},{})", x1, y1),
}
输出是(0,0) (0,0),这意味着原始结构仍然存在.它不应该在第一次之后被移动match吗？
我的课堂笔记有代码实现HasArea特征并打印区域,类似于Rust Book示例.教授的笔记如下:
trait HasArea<T> {
fn area(& self) -> T,
}
fn print<T: Display, S: HasArea<T>>(s: &S) {
println!("", s.area()); // println sth must impl Display trait
}
struct Circle {
x: T,
y: T,
r: T,
}
impl <T: Copy + Mul <Output = T>>
HasArea<T> for Circle<T>
{
fn area(&self) -> T {
self.r * self.r
}
}
将其与shape: T作为输入的Rust Book进行比较:
trait HasArea {
fn area(&self) -> f64;
}
struct Circle {
x: f64, …