为什么Python的列表推导不能复制参数,所以实际的对象不能变异？
Python的列表推导不能复制参数，所以实际的对象不能变异的原因是因为列表推导在创建新列表时会使用迭代器来遍历原始列表，并根据指定的条件生成新的元素。在这个过程中，列表推导会创建一个新的列表对象，而不是对原始列表进行修改。
具体来说，列表推导的语法是在方括号内使用表达式来生成新的列表元素，并可以包含一个可选的条件语句。例如，可以使用列表推导来生成一个原始列表中所有偶数的平方的新列表：
original_list = [1, 2, 3, 4, 5]
new_list = [x**2 for x in original_list if x % 2 == 0]在这个例子中，列表推导会遍历原始列表original_list，并将满足条件x % 2 == 0的元素的平方添加到新列表new_list中。注意，这里的original_list并没有被修改，而是创建了一个新的列表对象new_list。
由于列表推导是基于迭代器的，它在遍历原始列表时只会访问每个元素的值，并不会访问元素的引用。因此，即使在列表推导的表达式中修改了元素的值，也不会影响原始列表中的元素。
举个例子，假设有一个原始列表original_list包含三个字典元素：
original_list = [{'name': 'Alice'}, {'name': 'Bob'}, {'name': 'Charlie'}]如果尝试在列表推导中修改字典元素的值，例如将所有字典的name键的值改为大写，会发现原始列表并没有被修改：
new_list = [item.update({'name': item['name'].upper()}) for item in original_list]
print(original_list)输出结果为：
[{'name': 'Alice'}, {'name': 'Bob'}, {'name': 'Charlie'}]这是因为列表推导在遍历原始列表时只访问了字典元素的值，并没有修改原始列表中的元素。如果想要修改原始列表中的元素，需要使用循环来逐个访问和修改元素。
综上所述，Python的列表推导不能复制参数，所以实际的对象不能变异是因为列表推导在创建新列表时使用迭代器遍历原始列表，并根据条件生成新的元素，而不是对原始列表进行修改。如果需要修改原始列表中的元素，需要使用循环来逐个访问和修改元素。
相关·内容
2回答
转发初始化程序列表表达式
、、、
初始化程序列表表达式对于初始化C++容器非常方便：
std::vector<int>({1, 2, 3})
...but看起来，大括号括起来的初始化程序列表表达式(如{1,2,3} )只绑定到接受std::initializer_list<int>的函数--它似乎不绑定到通用(转发)引用。
template <class T>
void foo(T&& v)
{
std::vector<int>(std::forward<T>(v));
}
int main()
{
foo({1, 2, 3})
}
这一产出
浏览 3提问于2015-02-06得票数 17
回答已采纳
为什么你不能这么做呢？
constexpr auto foo()
{
return "hello";
}
int main()
{
// char s[] = foo();
auto s2 = foo();
const char* s3 = foo();
}
S给出错误。s2和s3都很好。
我认为这是可能的，但显然不是。
是的，我已经知道你不能这么做。你们没有人解释为什么你们不能这样做。
浏览 2提问于2014-12-15得票数 1
一般来说，这可能适用于大多数语言，但我不确定。我是Python的初学者，一直在处理C#和VB中的列表副本。但在Python中，每当我将列表作为参数传递并使用"for i in range“进行枚举，然后更改列表参数的值时，输入值实际上会更改原始列表。我认为Python应该默认按值传递参数，这样一旦函数完成，我仍然可以保留调用函数之前的原始值。我遗漏了什么？谢谢!
浏览 2提问于2009-10-09得票数 1
回答已采纳
2回答
在Python中，为什么切片操作在其行为上不一致？
对于列表和字符串，它的行为不同。
对于list，它给出一个复制list对象，对于字符串它给出相同的string对象。
我觉得这很令人困惑，违反直觉。有什么办法解释/证明这一点吗？
>>> s = "1234"
>>> s is (s[:2] + s[2:])
False
>>> s is s[:]
True
>>> lst = [1,2,3,4]
>>> lst is lst[:]
浏览 1提问于2019-01-24得票数 1
回答已采纳
我刚开始编写代码，我在一定程度上理解列表的行为。每当在函数的作用域内修改列表时，全局作用域中的列表也会发生变化。
例如,
def modify_list(lst):
lst.append(5)
lst = [1, 2, 3, 4]
#This output is [1, 2, 3, 4]
print(lst)
modify_list(lst)
#This output is [1, 2, 3, 4, 5] because of the function.
print(lst)
我不明白为什么这个例子行不通：
def modify_list(lst):
lst = [1,
浏览 4提问于2020-05-08得票数 1
回答已采纳
我是Python的新手。相同的代码在R上工作得很好，但我不明白为什么它在Python中不能工作.
Python：
#swap pair
def swap_pair(xpair):
if xpair[0] > xpair[1]:
xpair.reverse()
else:
xpair
return xpair
#swap_pass
def swap_pass(xlist):
for i in range(0,len(xlist)-1):
xlist[i:i+2] = swap_pair(xlist[i:i+2
浏览 2提问于2016-12-05得票数 0
回答已采纳
有一个类，它的构造函数接受"list type“的参数。此参数的默认值为空列表。构造函数使用此参数初始化其中一个类数据成员。然后，当我创建这个类的两个不同的实例对象时，它们都指向相同的列表。为什么会这样呢？
我尝试将默认值设置为None，然后在类构造函数主体中有条件地创建新的空列表。这是可行的。不同的对象实例在其类数据成员中具有不同的列表。但我想知道，当我在函数参数默认值init中创建一个列表时，它为什么不能像我预期的那样工作，如下面的代码所示：
class myClass:
def __init__(self, user_list=list()):
self.
浏览 1提问于2019-04-14得票数 0
1回答
我对下列守则的行为感到困惑：
data = [0,1,2,3,4,5]
class test():
def __init__(self,data):
self.data=data
self.data2=data
def main(self):
del self.data2[3]
test_var = test(data)
test_var.main()
print(test_var.data)
print(test_var.data2)
我认为应该说的是：
[0,1,2,3,4,5]
[0,1,2,4,5]
我得到的是：
[0,1,2,4,5]
[0,1,2,
浏览 4提问于2018-01-01得票数 2
回答已采纳
1回答
在STL中的许多地方和其他地方，您可以看到这样的代码：
template <typename Func>
void foo(Func f)
{
// ...
f();
}
即可调用参数f是通过值(的副本)传递的。为什么这似乎比键入Func&、const Func&或Func&&类型的参数更可取
浏览 2提问于2014-12-23得票数 2
2回答
class Obj {
public:
Obj(int aa, int bb): a(aa), b(bb) {}
Obj(const Obj& o) {a = o.a; b = o.b;std::cout << "copying" << std::endl;}
Obj(Obj&& o) {a = o.a; b = o.b;std::cout << "moving" << std::endl;}
int a;
int b;
};
const Obj&am
浏览 1提问于2018-10-15得票数 4
4回答
为什么下面的代码不能编译(在C++11模式下)？
#include <vector>
template<typename From, typename To>
void qux(const std::vector<From>&, To (&)(const From&)) { }
struct T { };
void foo(const std::vector<T>& ts) {
qux(ts, [](const T&) { return 42; });
}
错误消息为：
prog.cc:9:5
浏览 69提问于2017-01-29得票数 17
回答已采纳
为什么这个简单的代码不能工作？
template<class U>
class retype
{
typedef U type;
};
class object
{
public:
template<class U>
int create(typename retype<U>::type p)
{
return 4;
}
};
int main()
{
int n = object().create(5);
return 0;
}
和GCC一起编译的时候遇到这个错误：
tes
浏览 1提问于2013-01-01得票数 4
1回答
在本主题中，我们将学习如何将SFINAE与自动/自推导返回类型一起使用：
但是，当我还在使用可变模板时，我似乎不能应用任何技术。这是我的签名：
template<typename Scalar, class ClassDispatcher, typename... Args>
auto dispatch(Args&&... args) {}
我想使用SFINAE来专门介绍Scalar模板。但是由于标量参数没有出现在参数列表中，我发现很难在任何地方使用enable_if。由于参数包的原因，我无法将伪参数添加到参数列表或模板参数列表中。最后一个地方是返回类型，但如上所述
浏览 1提问于2017-04-02得票数 0
2回答
我想清理我编写的一些代码，以扩大我想要做的事情的规模。为了做到这一点，我想在理想情况下创建一个对象引用列表，这样我就可以使用循环系统地设置对象，而不必实际将对象放到列表中。我读过Python处理引用和传递的方式，但还没有找到有效的方法。
为了更好地展示我想要做的事情：
我使用bokeh，并希望设置大量的选择框。每个盒子都是这样的
select_one_name = Select(
title = 'test',
value = 'first_value',
options = ['first_value', '
浏览 3提问于2015-01-28得票数 3
回答已采纳
3回答
我试图按索引向现有列表中插入如下内容：
c = ['545646', 'text_item', '151561'].insert(1, '555')
print(c)
结果我什么也没得到。
为什么我不能插入Python列表？
所需产出如下：
['545646', '555', 'text_item', '151561']
浏览 0提问于2019-07-26得票数 2
回答已采纳
3回答
#include <iostream>
#include <vector>
using namespace std;
template <typename T>
void wrapper(T& u)
{
g(u);
}
class A {};
void g(const A& a) {}
int main()
{
const A ca;
wrapper(ca);
wrapper(A()); // Error
}
嗨，我有一个问题，为什么最后一条语句会产生编译器错误。
:18:10:错误:不能将“A&
浏览 0提问于2018-03-27得票数 4
回答已采纳
1回答
作为Python在这个问题上相对较新的一个方面，我可能会使用一些不正确的术语，并且会显示出误解--这就是我为什么在这里的原因。
我正在学习Python函数，并试图确保我理解变量是如何传递和返回的。
我编写了这个简单的函数来对列表中的项进行排序。
def func_sort_list(NN):
for w in NN:
print (w, type(w))
NN.sort()
print (NN)
return (w)
我已将值赋值给一个列表
unsort_letters=['q','w','e'
浏览 3提问于2017-04-04得票数 7
回答已采纳
您能描述一下函数中Python可选参数的行为吗？
我的理解是，可选参数使用函数定义中的默认值。
以下代码具有正确的行为。
# Function
def testf2(val=0):
val += 5
print(val)
val=0
return
# Testing
testf2()
testf2(10)
testf2()
# Output:
5
15
5
但是我不知道为什么带有可选列表的相似代码具有完全不同的行为。即使列表被val=[]清除，该函数也会记住一些数据。
# Function
def testf(val=[]):
val.append(
浏览 0提问于2016-05-17得票数 0
我的项目是babel7。
render() {
const {elementStyle, style } = this.props;
return (
<span style={Object.assign(elementStyle, style)}>{label}
</span>
)
}
//Object.Assition(elementStyle，style) -> error。但是我更正了Object.assign({}，elementStyle，style)正在工作。为什么不起作用？我
浏览 0提问于2019-01-29得票数 0
灵感来自“流利的Python”中的这个谜语：
t = (1, 2, [3,4])
t[2] += [5, 6]
对于那些不知道的人，这会引发一个错误，但会改变元组。
我不明白两件事：
为什么t[2].extend([5, 6])会工作，没有任何错误？
为什么在字典中插入新条目时没有任何错误：
t = (1, {}) t[1]["name"] = "bob"
浏览 2提问于2017-08-21得票数 0
回答已采纳
2回答
我正在创建一个简单的程序来生成一个由数字、符号和字符组成的“列表”密码。在这个过程中，我想随机化和洗牌。我使用random.shuffle方法对列表进行了洗牌。我的问题(对不起，Python非常新)--为什么我们不能将洗牌活动的结果存储到一个变量中。举个例子。
mylist = ["apple", "banana", "cherry"]
shufflefinal = random.shuffle(mylist)
(为什么我们不能将random.shuffle(mylist)存储到变量洗牌中)这里的规则是什么？我理解如何获得结果，但我想了解为什么不
浏览 6提问于2022-02-13得票数 -1
回答已采纳
我想编写一个Python函数，它会改变其中一个参数(这是一个列表，即可变的)。就像这样：
def change(array):
array.append(4)
change(array)
与Python的设置相比，我更熟悉按值传递(无论您如何称呼它)。所以我通常会写这样一个函数：
def change(array):
array.append(4)
return array
array = change(array)
这是我的困惑。由于我只需改变论点，第二种方法就显得多余了。但第一个感觉不对。另外，我的特定函数将有几个参数，其中只有一个参数会改变。第二个方法清楚地说明了什么参
浏览 3提问于2014-09-24得票数 31
回答已采纳
3回答
我有一个std::vector<std::vector<double>>，并想在它的末尾添加一些元素，所以这是我的试验：
std::vector<std::vector<double> > vec;
vec.emplace_back({0,0});
但是这不能编译，而下面的代码可以：
std::vector<double> vector({0,0});
为什么emplace_back不能在这个位置构造元素？或者我做错了什么？
谢谢你的帮助。
浏览 0提问于2014-07-03得票数 25
回答已采纳
所有的例子都来自和。
具体来说，
template<class...> struct Tuple { };
template< class... Types> void g(Tuple<Types ...>); // #1
// template<class T1, class... Types> void g(Tuple<T1, Types ...>); // #2
template<class T1, class... Types> void g(Tuple<T1, Type
浏览 1提问于2015-10-29得票数 1
回答已采纳
3回答
因此，我有一个与python中函数中变量的范围相关的问题，请考虑以下代码：
import numpy as np
def function(data, mask):
data *= mask
data = np.ones(5)
for x in range(2):
print(data)
mask = np.array([1, 0, 0, 0, 0])
function(data, mask)
输出如下：
[1. 1. 1. 1. 1.]
[1. 0. 0. 0. 0.]
我的问题是，为什么data在第一次迭代之后会改变呢？我一直认为函数的局部变量是..
浏览 16提问于2022-10-21得票数 0
回答已采纳
我很惊讶下面的代码导致了一个could not deduce template argument for T错误：
struct foo
{
template <typename T>
void bar(int a, T b = 0.0f)
{
}
};
int main()
{
foo a;
a.bar(5);
return 0;
}
调用a.bar<float>(5)解决了这个问题。为什么编译器不能从默认参数中推导出类型？
浏览 0提问于2012-03-09得票数 25
回答已采纳
码
def change1(list1):
list1[1] = list1[1] + 5
def change2(number):
number = number + 2
def main():
numbers = [4, 8, 12]
change1(numbers)
variable = 15
change2(variable)
i = 0
while i < 3:
print numbers[i]
浏览 9提问于2011-08-13得票数 0
在查看来自的std::apply引用时，我们可以看到函数模板不能作为std::apply的可调用对象传递。让我们考虑以下函数模板：
template<typename T>
T add_generic(T first, T second) { return first + second; }
因此，由于无法在std::apply call中推导函数模板，因此不能使用折叠代码：
std::apply(add_generic, std::make_pair(2.0f, 3.0f)); // Error: can't deduce the function type
请注意，这不
浏览 0提问于2021-10-24得票数 5
回答已采纳
1回答
我随机编写了函数，这些函数接受数组引用并返回数组，并从旧数组初始化一个新数组：
#include <iterator>
#include <iostream>
using namespace std;
template <typename T>
T& return_arr(T& arr) {
return arr;
}
int main(){
double a[] = {1,2,4.5,9};
auto x = return_arr(a);
a[2] = 5;
cout << x[2]
浏览 6提问于2014-02-25得票数 1
回答已采纳
1回答
编译器错误“没有匹配函数的调用”，在我的情况下，一个查找函数中的链接列表。
为什么会有这个错误？
函数
template<class T>
int find(std::shared_ptr<Node<T>> ptr, T val) {
int pos(0);
while (ptr) {
if (ptr->val == val)
return pos;
else {
ptr = ptr->next;
pos++;
浏览 6提问于2017-08-10得票数 1
回答已采纳
我认为对传递给python函数的变量的更改保留在该函数的局部作用域中，而不会传递到全局作用域。但是当我写一个测试脚本时：
#! /usr/bin/python
from numpy import *
def fun(box, var):
box[0]=box[0]*4
var=var*4
return 0
ubox,x = array([1.]), 1.
print ubox,x
fun(ubox,x)
print ubox,x
输出为：
[myplay4]$ ./temp.py
[ 1.] 1.0
[ 4.] 1.0
整数变量x不受函数内部操作的影响，但数组受影
浏览 0提问于2013-01-27得票数 0
回答已采纳
我正在尝试遍历Python中的列表，对其进行一些更改，然后输出结果。下面是函数：
def scramble_bytes(self, ref_key):
"""
Uses ref_key as a reference to scramble self.
They must be equal-length lists of bytes
"""
if len(self) != len(ref_key):
return "Inputs to scramble_bytes must be e
浏览 1提问于2017-09-24得票数 0
为什么screen不能正确初始化框架结构？
我想要的是初始化屏幕结构，并直接初始化2帧结构。
#include <iostream>
#include <sstream>
#include <cstring>
#define ESC "\033"
struct frame {
public:
frame(unsigned int w, unsigned int h) :
m_w(w),
m_h(h) {}
private:
unsigned int m_w, m_h;
};
struct
浏览 2提问于2018-11-07得票数 0
2回答
为什么剪接反应不正确？
、、、
我正在尝试使用delete按钮.I从列表中删除行，如下所示
if (state.indexOf(action.payload) > -1) {
console.log('iff----')
state.splice(state.indexOf(action.payload), 1);
}
console.log(state)
return state
但是它不是删除行，.here是我的代码，实际上是使用add按钮，我正在生成项目列表，还有删除按钮，我正在尝试使用delete button从列表中删除项目，
浏览 5提问于2017-01-02得票数 8
回答已采纳
这看起来可能类似于，但是我实际上是通过值传递std::function参数，所以这个问题不适用。我定义了以下函数。
template<typename T>
std::vector<T> countSort(const std::vector<T> &v, std::function<int(T)> keyFunc, int n);
第二个参数是一个std::function，它将T映射到int (通过值传递)。
在调用它时，我希望使用lambda表达式，如下所示：
std::vector<int> v;
[...]
v =
浏览 5提问于2020-08-24得票数 1
回答已采纳
3回答
给定一个lambda：
auto f = [](const T& var){ return var; };
为什么f的返回类型是T (不是const T&)？这在标准中处于什么位置？
浏览 3提问于2016-10-21得票数 5
1回答
非类型参数的非推导上下文
、、、、
我正在阅读C++模板(第二版)，这是本书的一个片段：
template<typename... Ts, int N>
void f(double (&)[N+1], Ts... ps) {return;}
书中规定，上面的声明是无用的，因为N不能被指定或推导。
我试图理解为什么像下面这样的东西是错误的：
double arr[2];
f<int, double, 1>(arr, 1, 2.0);
当我编译上面的片段时，我会得到一个错误，即对f的调用没有匹配的函数。
这编译得很好
template<typename... Ts, typename T>
浏览 0提问于2018-12-15得票数 13
回答已采纳
1回答
因此，我对python有一个非常基本的理解(为期10周的夏季课程由python和Matlab组成)。我试图创建一个如下所示的2d列表：
data.append (samples)
data.append (matches)
data_list.append (data)
data.clear()
这是在for循环中运行的，每次迭代时都会写入。然而，当我运行它和我的print(data_list)我得到一个空的列表。
我像这样成功地运行了它：
data.append (samples)
data.append (matches)
data_list.append (data)
data = []
浏览 1提问于2018-06-27得票数 1
回答已采纳
2回答
如果参数列表绑定到类，则参数包必须位于参数列表末尾的原因是什么，而如果参数列表是成员方法声明的一部分，则约束会放松。
从其他方面来说，这一条汇编如下：
class C {
template<typename T, typename... Args, typename S>
void fn() { }
};
以下这一条没有：
template<typename T, typename... Args, typename S>
class C { };
为什么第一种情况被认为是正确的，而第二种情况则是不正确的？
我是说，如果这是法律语法的话，这两种情况都应该
浏览 6提问于2016-01-22得票数 28
回答已采纳
3回答
你能解释一下为什么下面的代码不能编译吗？一个明显的解决方法是添加一个Apply的单参数重载，有没有更简单的方法？
template <typename T>
T Identity(const T& i_val)
{
return i_val;
}
template <typename Val, typename Fn>
Val Apply(const Val& v, Fn fn = Identity<Val>)
{
return fn(v);
}
int main() {
Apply(42);
浏览 0提问于2012-08-20得票数 12
回答已采纳
1回答
我有一个函数foo，它以变量函数指针作为参数。
我希望在函数声明之前使用“使用”来定义参数的类型。
template <typename ... vARGS>
using TFuncType = void(*)(vARGS ... V_args);
template <typename ... vARGS>
void foo(TFuncType<vARGS ...> funcptr) {}
void bar(int i) {}
int main() {
foo(&bar); // This line fails to compile.
}
浏览 2提问于2015-07-04得票数 15
回答已采纳
如果我传入一个列表，我就很难理解python函数中的奇怪行为。我创建了以下函数：
def func(x):
y = [4, 5, 6]
x = y
def funcsecond(x):
y = [4, 5, 6]
x[1] = y[1]
x = [1, 2, 3]
当我调用func( x )然后打印x时，它打印出1，2，3，就像x之前的方式一样，它不会将列表y赋给x。但是，如果我调用funcsecond(x)，它会将5赋给x的第二个位置。为什么？当我赋值整个列表时，它不会做任何事情，但是当我只赋值一个元素时，它会改变我最初调用它的列表。非常感谢你，我希望你能
浏览 0提问于2012-06-21得票数 3
回答已采纳
2回答
我正在做一种类似这样的包装：
#include <iostream>
template<class T, class Value>
void Apply(void (T::*cb)(Value), T* obj, Value v)
{
(obj->*cb)(v);
}
class Foo
{
public:
void MyFunc(const int& i)
{
std::cout << i << std::endl;
}
const int& GetValue(
浏览 1提问于2016-11-08得票数 11
回答已采纳
此代码无法编译
template<unsigned n>
void test(char const (*)[n + 1]) { }
int main()
{
char const arr[] = "Hi";
test(&arr);
}
有错误
note: candidate template ignored: couldn't infer template argument 'n'
但是，如果您将n + 1更改为n，则它编译得很好。
为什么编译器在添加偏移量时不能推断n呢？
浏览 3提问于2021-10-02得票数 6
回答已采纳
2回答
我编写了一个函数SwapCities，它能够交换列表中的条目3和4。
所以f.e。0,1,2,3,4应该变成0,1,2,4,3。这个函数工作得很好，但奇怪的是，我原来的列表也不想改变。
这是我的密码：
def SwapCities(solution):
n = 3##randint(0,NumberOfCities-1)
m = 4##randint(0,NumberOfCities-1)
result = solution
temp1 = solution[n]
temp2 = solution[m]
result[n] = temp2
浏览 2提问于2013-05-18得票数 0
1回答
尝试1
>>> width = 3
>>> height = 2
>>> zeros = [[0]*width]*height
>>> print(zeros)
[[0, 0, 0], [0, 0, 0]]
>>> zeros[1][2] = "foo"
>>> print(zeros)
[[0, 0, 'foo'], [0, 0, 'foo']]
预期结果为[[0, 0, 0], [0, 0, 'foo']]。似乎*操作符
浏览 5提问于2021-05-12得票数 0
回答已采纳
2回答
我一直在研究PyTorch中的遗传算法，在尝试改变模型的参数时遇到了一个问题。我一直在使用.apply()函数随机更改模型的权重和偏差。下面是我创建的确切函数： def mutate(m):
if type(m) == nn.Linear:
m.weight = nn.Parameter(m.weight+torch.randn(m.weight.shape))
m.bias = nn.Parameter(m.bias+torch.randn(m.bias.shape)) 这个函数确实有效，我已经测试过了，但这不是最奇怪的部分。当尝试对列表中的每个模型
浏览 14提问于2021-09-27得票数 0
回答已采纳
我不能理解Python是如何处理变量和列表的--我想把一个50个元素的数组克隆成一个100个元素的数组，但是每个元素后面跟着一个具有相同值和字段的元素，但是对于一个字段，用True代替False。 global A
A = list()
for i in range(100):
A.append(0)
index = 0
for i in range(50):
A[index] = self.b[i]
A[index + 1] = self.b[i]
print ("It was " + str(A[index].f)) # always
浏览 17提问于2020-01-06得票数 0
回答已采纳
就像std::reference_wrapper在幕后使用指针来存储“引用”一样，我也在尝试用下面的代码做类似的事情。
#include <type_traits>
struct Foo
{
void* _ptr;
template<typename T>
Foo(T val,
typename std::enable_if
<
std::is_reference<T>::value,
void
&
浏览 0提问于2012-06-06得票数 3
回答已采纳
4回答
我们在Python中知道这一点
a= [1, 2]
b= [a, a]
print b
[[1, 2], [1, 2]]
a.append(3)
print b
[[1, 2, 3], [1, 2, 3]]
这是因为b有相同列表a的引用，在a中追加anthing也会改变b。
我的问题是--这种行为的用途或优势是什么？
为什么Python会引用赋值？？
如果我在模糊地做b =[a,a]，这意味着我对a的值感兴趣，而不是对a后来发生的事情感兴趣。
我们可以像这样实现这一点
b=[a[:], a[:]]
#or
b=[a,a]
a=[]
但是为什么这不是python的默认行为呢？为什么Python
浏览 0提问于2012-09-27得票数 0
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
实时音视频
对象存储
云直播活动推荐
腾讯云开发者
