关于复制问题

今天的我更强了

def func(ls=[]):
    ls.append(1)
    return ls
a=func()
b=func()
print(a,b)
求大佬解释一下为什么答案是[1,1] [1,1]

灰晨

传入的参数为变量ls，指向的[]在定义函数之前创建，而不是每次执行前重新创建一个新列表对象

青出于蓝

1. def func(ls):
   
2.     ls.append(2)
   
3.     print(ls)
   
4.     return ls
   
5. a=func([])
   
6. b=func([])
   
7. print(a,b)
   

复制代码

在函数后面写参数的括号内定义列表,集合,字典都会这样

青出于蓝

灰晨 发表于 2021-7-16 16:29
传入的参数为变量ls，指向的[]在定义函数之前创建，而不是每次执行前重新创建一个新列表对象

那为何如果ls是字符就没事勒？

Mzzith

a = func()时 调用一次 b = func()时又调用一次 且进行存储  print(a,b)时 就已经执行了俩次func()

灰晨

青出于蓝 发表于 2021-7-16 16:36
那为何如果ls是字符就没事勒？

像你的代码这样，只是 ls，就代表你这个参数没有默认值
没有默认值，你调用的时候就必须传参
a=func([])
b=func([])
这时 ls 这个变量指向的就是你传入的 []
你在函数里开头打印一下它的id

1. def func(ls):
   
2.     print(id(ls))
   
3.     ls.append(2)
   
4.     print(ls)
   
5.     return ls
   
6. a=func([])
   
7. b=func([])
   
8. print(a,b)
   

复制代码

会发现，就算同样是 [] ，它们的储存地址也是不一样的，是不同的两个列表
而有默认值的参数，该默认值在定义函数前就创建了，类似于

1. a = []
   
2. def func(ls):
   
3.     print(id(ls))
   
4.     ls.append(2)
   
5.     print(ls)
   
6.     return ls
   
7. a=func(a)
   
8. b=func(a)
   
9. print(a,b)
   

复制代码

就是说，你参数有默认值，而之后调用参数的时候没有进行传参，则 变量ls默认指向你的默认值的id，如

1. def func(ls=[]):
   
2.     print(id(ls))
   
3.     ls.append(2)
   
4.     print(ls)
   
5.     return ls
   
6. a=func()
   
7. b=func([6])
   
8. c=func()
   
9. print(a,b,c)
   

复制代码

a没有进行传参，所以，ls默认指向[],在[]中添加2，成[2]
b进行了传参，则，ls指向传入的参数[6],在该列表中添加2，成[6,2]
注，此时实际有两个列表了，一个[2],另一个[6,2]
c同样没有进行传参，所以，ls依旧指向默认值的id，而此时该默认值为[2]
列表中的值虽然变了，不过列表还是默认的那个列表，在该列表中添加2，成[2,2]
即，此时python存储了两个列表，一个是默认的列表，一个是你自己定义的列表，
一个为[2,2]， 一个为[6,2]

灰晨

建议，默认值最好还是别设定成可变对象
代码很少还好说，代码一多，别人看起来，不，自己之后看都得疯

青出于蓝

灰晨 发表于 2021-7-16 17:19
建议，默认值最好还是别设定成可变对象
代码很少还好说，代码一多，别人看起来，不，自己之后看都得疯

这个我懂，主要是按楼主的代码，他是在函数后那个传入参数括号内定义的变量，就出现了问题。但楼主将ls命名为了列表，如果ls是字符串，就不会有问题了。

灰晨

青出于蓝 发表于 2021-7-16 17:24
这个我懂，主要是按楼主的代码，他是在函数后那个传入参数括号内定义的变量，就出现了问题。但楼主将ls ...

因为字符串是不可变对象啊，比如说

1. def func(ls='a'):
   
2.     print(ls)
   
3.     print(id(ls))
   
4.     ls = ls + 'b'
   
5.     print(ls)
   
6.     print(id(ls))
   
7.     return ls
   
8. a=func()
   
9. b=func()
   
10. print(a,b)

复制代码

你看，ls 指向默认值'a'，'a'的id是没有变，假如'a'的id是1234
那么，调用函数不传参，则，ls——>1234——>a
按楼主的代码，假如 [] 的id为789，
那么，调用函数不传参，则，ls——>789——>[]
但列表是可变对象啊，append(1)后[]就成了[1],可是列表还是那个列表，它的id没有变的
之后再调用函数不传参，就是，ls——>789——>[1]

ls = ls + 'b'
这里改变了 ls 的指向，ls 现在的指向是 'ab' , 'ab'的id 跟 'a' 的id 肯定不一样了
之后b=func()，此时再次调用还是不传参，ls 依旧是指向默认值，而默认值就是 id为 1234的 'a'，而不是'ab'

Kayko