python类初始化__init__()方法中使用[]作为形参的默认值（空列表为默认值初始化类实例属性）导致的问题和分析

最新推荐文章于 2024-02-02 07:51:39 发布
最新推荐文章于 2024-02-02 07:51:39 发布
阅读量5k 收藏 17
点赞数 9
分类专栏： python 文章标签： python 面向对象编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yue81560/article/details/114648610
版权

目录

问题的发现

在编写一个拓扑计算图的节点类时，更新实例节点的实例属性 self.inputs(inputs为list类型)时，发现一个实例的更新，会引起继承该类的所有的inputs均会更新，经过反复的测试后，发现问题出现在__init__()中inputs设置了默认值[]。这个inputs在init函数中是对self.inputs进行初始化操作，从而使得所有的self.inputs都具有同样的地址。

下面将通过简单的demo来示意问题出现的特征，和分析python这门语言的一些原理。

问题解析

问题重现

定义一个Food()类，并定义10个实例，实例属性，self.feature为list的属性，一开始初始化为[].对其中的一部分实例的属性进行self.inputs进行操作。

class Food():
	def __init__(self,feature=[],name=None):
		self.price=0
		self.feature=feature

Food_dict={}
for key in range(10):
	Food_dict[key]=Food()

for key in range(0,10,2):
	Food_dict[key].feature.append("撞羊")

for key in range(10):
	print(f"当前的食物{key}")
	print(Food_dict[key].feature)

其运行结果如下：

	当前的食物0
	['撞羊', '撞羊', '撞羊', '撞羊', '撞羊']
	当前的食物1
	['撞羊', '撞羊', '撞羊', '撞羊', '撞羊']
	当前的食物2
	['撞羊', '撞羊', '撞羊', '撞羊', '撞羊']
	当前的食物3
	['撞羊', '撞羊', '撞羊', '撞羊', '撞羊']
	当前的食物4
	['撞羊', '撞羊', '撞羊', '撞羊', '撞羊']
	当前的食物5
	['撞羊', '撞羊', '撞羊', '撞羊', '撞羊']
	当前的食物6
	['撞羊', '撞羊', '撞羊', '撞羊', '撞羊']
	当前的食物7
	['撞羊', '撞羊', '撞羊', '撞羊', '撞羊']
	当前的食物8
	['撞羊', '撞羊', '撞羊', '撞羊', '撞羊']
	当前的食物9
	['撞羊', '撞羊', '撞羊', '撞羊', '撞羊']

分析程序我们知道，我们对10个实例中为偶数的实例的self.feature进行append(“撞羊”)操作，但每个实例都进行了append(“撞羊”)操作，而且都进行了五次，这说明对一个实例的self.feature进行append()的时候，其他实例也同时进行操作了。

在我们定义的__init__()方法中，将feature设为可变变量，并给予[]的默认值。想要达到的效果是：新建Food()的实例时，其feature为空，然后我们动态的将属性添加到feature里。由于feature是实例类型的变量，也就是每一个实例均有一个feature属性，相互之间理应相互独立。但上述却出现了改变一个实例的属性，其他类型的属性也一并修改的情况。

寻找发生原因

我们使用python的内置方法id()输出每个变量的feature的唯一标识符(内存地址)以及__init__()的feature形参的变量地址，以及类定义前后以及for循环中的[]的id。代表如下：

print(f"类定义前的[]的唯一标识符{id([])}")
class Food():
	print(f"类定义开头的[]的唯一标识符{id([])}")
	def __init__(self,feature=[],name=None):
		print(f"形参feature的唯一标识符{id(feature)}")
		self.price=0
		self.feature=feature
		print(f"实例{name}的feature属性的唯一标识符{id(self.feature)}")

	print(f"类定义结束的[]的唯一标识符{id([])}")
print(f"类定义后的[]的唯一标识符{id([])}")
Food_dict={}
for key in range(10):
	print(f"循环中的[]的唯一标识符{id([])}")
	Food_dict[key]=Food(name=key)

print(f"循环完成后的[]的唯一标识符{id([])}")
for key in range(0,10,2):
	Food_dict[key].feature.append("撞羊")

for key in range(10):
	print(f"当前的食物{key}")
	print(Food_dict[key].feature)

print(f"程序运行结束的[]的唯一标识符{id([])}")

程序输出结果如下：

	类定义前的[]的唯一标识符964654623688
	类定义开头的[]的唯一标识符964654623688
	类定义结束的[]的唯一标识符964654620808
	类定义后的[]的唯一标识符964654623624
	循环中的[]的唯一标识符964654623624
	形参feature的唯一标识符964654623688
	实例0的feature属性的唯一标识符964654623688
	循环中的[]的唯一标识符964654623624
	形参feature的唯一标识符964654623688
	实例1的feature属性的唯一标识符964654623688
	循环中的[]的唯一标识符964654623624
	形参feature的唯一标识符964654623688
	实例2的feature属性的唯一标识符964654623688
	循环中的[]的唯一标识符964654623624
	形参feature的唯一标识符964654623688
	实例3的feature属性的唯一标识符964654623688
	循环中的[]的唯一标识符964654623624
	形参feature的唯一标识符964654623688
	实例4的feature属性的唯一标识符964654623688
	循环中的[]的唯一标识符964654623624
	形参feature的唯一标识符964654623688
	实例5的feature属性的唯一标识符964654623688
	循环中的[]的唯一标识符964654623624
	形参feature的唯一标识符964654623688
	实例6的feature属性的唯一标识符964654623688
	循环中的[]的唯一标识符964654623624
	形参feature的唯一标识符964654623688
	实例7的feature属性的唯一标识符964654623688
	循环中的[]的唯一标识符964654623624
	形参feature的唯一标识符964654623688
	实例8的feature属性的唯一标识符964654623688
	循环中的[]的唯一标识符964654623624
	形参feature的唯一标识符964654623688
	实例9的feature属性的唯一标识符964654623688
	循环完成后的[]的唯一标识符964654623624
	当前的食物0
	['撞羊', '撞羊', '撞羊', '撞羊', '撞羊']
	当前的食物1
	['撞羊', '撞羊', '撞羊', '撞羊', '撞羊']
	当前的食物2
	['撞羊', '撞羊', '撞羊', '撞羊', '撞羊']
	当前的食物3
	['撞羊', '撞羊', '撞羊', '撞羊', '撞羊']
	当前的食物4
	['撞羊', '撞羊', '撞羊', '撞羊', '撞羊']
	当前的食物5
	['撞羊', '撞羊', '撞羊', '撞羊', '撞羊']
	当前的食物6
	['撞羊', '撞羊', '撞羊', '撞羊', '撞羊']
	当前的食物7
	['撞羊', '撞羊', '撞羊', '撞羊', '撞羊']
	当前的食物8
	['撞羊', '撞羊', '撞羊', '撞羊', '撞羊']
	当前的食物9
	['撞羊', '撞羊', '撞羊', '撞羊', '撞羊']
	程序运行结束的[]的唯一标识符964654623624

从结果分析，可以看到id([])有三种结果

  1. 类定义开始前和类定义开头，以及__init__()中的形参feature，以及实例变量self.feature含有同样的id：964654623688
  2. 类定义结尾[]的id：964654620808
  3. 类代码段后，以及在生成各实例的循环中的和程序运行结尾的id():964654623624

从结果1，我们变不难发现，他们共享了同一地址。 所以，当我们对self.feature进行append操作时，只改变了内存地址中的值，其他实例变量当然也读取到了变化后的值。

问题背后的python原理分析

这里涉及到python的变量类型和变量不同类型的引用方法的原理。（这一部分经常听人叨叨，没想到我也要叨叨一遍，但是理解这一点很必要）

python可分为可变数据类型和不可变数据类型。可变数据类型，赋值时，诸如a=["a",],是把保存[“a”,]这个列表的内存地址给了变量a。如果我们再次赋值b=a，然后改变b的值:b.append("b"),我们可以发现，a和b会同时改变，如：

print("*"*50)
a=[1]
print(f"a的ID{id(a)}")
b=a
print(f"b的ID{id(b)}")
c=a+b
print("a+b运算了")
print(f"a的ID{id(a)}")
print(f"b的ID{id(b)}")
b+=[2]
print(b)
print(f"b更改值后，a的id{id(a)}")
print(f"b更改值后，b的id{id(b)}")

程序输出的结果：

	**************************************************
	a的ID964654623624
	b的ID964654623624
	a+b运算了
	a的ID964654623624
	b的ID964654623624
	[1, 2]
	b更改值后，a的id964654623624
	b更改值后，b的id964654623624

不可变数据数据类型，其实一开始赋值时和相互传值时，也是指向同一内存地址的，只有当其值改变时，才会指向不同的内存地址：

print("*"*50)
a=1
print(f"a的ID{id(a)}")
b=a
print(f"b的ID{id(b)}")
c=a+b
print("a+b运算了")
print(f"a的ID{id(a)}")
print(f"b的ID{id(b)}")
b+=1
print(b)
print(f"b更改值后，a的id{id(a)}")
print(f"b更改值后，b的id{id(b)}")

程序输出：

	**************************************************
	a的ID1448438816
	b的ID1448438816
	a+b运算了
	a的ID1448438816
	b的ID1448438816
	2
	b更改值后，a的id1448438816
	b更改值后，b的id1448438848

可以看到，一开始a和b的ID也是一样的

但是上述问题是可变类型的原因嘛？

我们在__init__()赋值的是一个具体的list，可以说是一个常量。并没有引用其他的变量。为什么所有的实例仍然共享同一个地址？

可以看到在类代码段前以及类代码段开始运行的开头的[]是同一个内存地址，但是类代码段运行到结束[]的内存地址变化了，而跳出类代码段后，以及接下来的运行过程中，[]的内存地址又变化了。而在循环生成类实例时，实例所用的[]的内存地址，却是指向了类代码段前以及类代码段开始运行的开头的[]的内存地址

这里我认为至少涉及了三个问题，我之前并没有深入的考虑过：

  1. python的函数只有在引用的时候执行，但是def 语句出现时，就python就已经为这个函数创建一个函数对象，并将其赋值给函数名。函数中定义的形参作为函数对象的参数，创建一个与函数相关的命名空间。就是函数的形参其实在def 语句运行的时候，就已经把它们存在某一个地方了，函数调用的时候，就先把这些参数的内存地址再传过来。

  2. python的类代码在一开始出现的时候，会执行。类中定义的函数的 def 语句也会像1中所描述的那样执行。这个特点也能理解在类属性的定义和引用的问题，如:

    class A():
	property_1=2
	self.property_2=4

就因为在类代码出现的时候，property_1=2已经执行了，所以我们才能引用A.property_1。而因为运行类代码的时候，根本没有实例，所以self不存在，则A.property_2会报错。

  1. 当将[]赋值给一个变量时，[]所指向的内存地址会变，解释：上面的:

    类代码段运行到结束[]的内存地址和类代码段运行开头[]内存地址不一致的问题

这个问题目前不知道到底是什么原理，但是这种做法比较符合逻辑。因为[]指向的地址不变，那python中所有的list都将指向同一内存地址。可以通过程序来观察这种变化：

print(id([]))
b=[]
print(id([]))
c=[]
print(id([]))

#程序输出
#795369109640
#795369171848
#795369169032

问题的解决方法

  1. feature作为必选参数，在定义类时，必须传入为[]，如代码：
	print("*"*50)
	a=[1]
	print(f"a的ID{id(a)}")
	b=a
	print(f"b的ID{id(b)}")
	c=a+b
	print("a+b运算了")
	print(f"a的ID{id(a)}")
	print(f"b的ID{id(b)}")
	b+=[2]
	print(b)
	print(f"b更改值后，a的id{id(a)}")
	print(f"b更改值后，b的id{id(b)}")
	print(f"类定义前的[]的唯一标识符{id([])}")
class Food():
	print(f"类定义开头的[]的唯一标识符{id([])}")
	def __init__(self,feature,name=None):
		print(f"形参feature的唯一标识符{id(feature)}")
		self.price=0
		self.feature=feature
		print(f"实例{name}的feature属性的唯一标识符{id(self.feature)}")

	print(f"类定义结束的[]的唯一标识符{id([])}")
print(f"类定义后的[]的唯一标识符{id([])}")
Food_dict={}
for key in range(10):
	print(f"循环中的[]的唯一标识符{id([])}")
	Food_dict[key]=Food(name=key,feature=[])

print(f"循环完成后的[]的唯一标识符{id([])}")
for key in range(0,10,2):
	Food_dict[key].feature.append("撞羊")

for key in range(10):
	print(f"当前的食物{key}")
	print(Food_dict[key].feature)

print(f"程序运行结束的[]的唯一标识符{id([])}")

程序的输出结果：

	类定义前的[]的唯一标识符486727131528
	类定义开头的[]的唯一标识符486727131528
	类定义结束的[]的唯一标识符486727131528
	类定义后的[]的唯一标识符486994340616
	循环中的[]的唯一标识符486994340616
	形参feature的唯一标识符486994340616
	实例0的feature属性的唯一标识符486994340616
	循环中的[]的唯一标识符486727131528
	形参feature的唯一标识符486727131528
	实例1的feature属性的唯一标识符486727131528
	循环中的[]的唯一标识符486994340744
	形参feature的唯一标识符486994340744
	实例2的feature属性的唯一标识符486994340744
	循环中的[]的唯一标识符486994340680
	形参feature的唯一标识符486994340680
	实例3的feature属性的唯一标识符486994340680
	循环中的[]的唯一标识符486994340040
	形参feature的唯一标识符486994340040
	实例4的feature属性的唯一标识符486994340040
	循环中的[]的唯一标识符486994340296
	形参feature的唯一标识符486994340296
	实例5的feature属性的唯一标识符486994340296
	循环中的[]的唯一标识符486994340104
	形参feature的唯一标识符486994340104
	实例6的feature属性的唯一标识符486994340104
	循环中的[]的唯一标识符486994340168
	形参feature的唯一标识符486994340168
	实例7的feature属性的唯一标识符486994340168
	循环中的[]的唯一标识符486994340488
	形参feature的唯一标识符486994340488
	实例8的feature属性的唯一标识符486994340488
	循环中的[]的唯一标识符486994340232
	形参feature的唯一标识符486994340232
	实例9的feature属性的唯一标识符486994340232
	循环完成后的[]的唯一标识符486994311304
	当前的食物0
	['撞羊']
	当前的食物1
	[]
	当前的食物2
	['撞羊']
	当前的食物3
	[]
	当前的食物4
	['撞羊']
	当前的食物5
	[]
	当前的食物6
	['撞羊']
	当前的食物7
	[]
	当前的食物8
	['撞羊']
	当前的食物9
	[]
	程序运行结束的[]的唯一标识符486994311304
	**************************************************
	a的ID486994311304
	b的ID486994311304
	a+b运算了
	a的ID486994311304
	b的ID486994311304
	[1, 2]
	b更改值后，a的id486994311304
	b更改值后，b的id486994311304

可以看到只有对应实例的变量的feature属性被更改了，

  1. 方法2：使用关键字参数
print(f"类定义前的[]的唯一标识符{id([])}")
class Food():
	print(f"类定义开头的[]的唯一标识符{id([])}")
	def __init__(self,name=None,**kwargs):
		# 当关键字参数含有featuer就引用，没有默认为[]
		feature=kwargs.get("feature",[])
		print(f"形参feature的唯一标识符{id(feature)}")
		self.price=0
		self.feature=feature
		print(f"实例{name}的feature属性的唯一标识符{id(self.feature)}")

	print(f"类定义结束的[]的唯一标识符{id([])}")
print(f"类定义后的[]的唯一标识符{id([])}")
Food_dict={}
for key in range(10):
	print(f"循环中的[]的唯一标识符{id([])}")
	Food_dict[key]=Food(name=key,feature=[])

print(f"循环完成后的[]的唯一标识符{id([])}")
for key in range(0,10,2):
	Food_dict[key].feature.append("撞羊")

for key in range(10):
	print(f"当前的食物{key}")
	print(Food_dict[key].feature)

print(f"程序运行结束的[]的唯一标识符{id([])}")

程序输出：

	类定义前的[]的唯一标识符486994370696
	类定义开头的[]的唯一标识符486994370696
	类定义结束的[]的唯一标识符486994370696
	类定义后的[]的唯一标识符486994311240
	循环中的[]的唯一标识符486994340232
	形参feature的唯一标识符486994340232
	实例0的feature属性的唯一标识符486994340232
	循环中的[]的唯一标识符486994340488
	形参feature的唯一标识符486994340488
	实例1的feature属性的唯一标识符486994340488
	循环中的[]的唯一标识符486994340168
	形参feature的唯一标识符486994340168
	实例2的feature属性的唯一标识符486994340168
	循环中的[]的唯一标识符486994340104
	形参feature的唯一标识符486994340104
	实例3的feature属性的唯一标识符486994340104
	循环中的[]的唯一标识符486994340296
	形参feature的唯一标识符486994340296
	实例4的feature属性的唯一标识符486994340296
	循环中的[]的唯一标识符486994340040
	形参feature的唯一标识符486994340040
	实例5的feature属性的唯一标识符486994340040
	循环中的[]的唯一标识符486994340680
	形参feature的唯一标识符486994340680
	实例6的feature属性的唯一标识符486994340680
	循环中的[]的唯一标识符486994340744
	形参feature的唯一标识符486994340744
	实例7的feature属性的唯一标识符486994340744
	循环中的[]的唯一标识符486727131528
	形参feature的唯一标识符486727131528
	实例8的feature属性的唯一标识符486727131528
	循环中的[]的唯一标识符486994340616
	形参feature的唯一标识符486994340616
	实例9的feature属性的唯一标识符486994340616
	循环完成后的[]的唯一标识符486994311240
	当前的食物0
	['撞羊']
	当前的食物1
	[]
	当前的食物2
	['撞羊']
	当前的食物3
	[]
	当前的食物4
	['撞羊']
	当前的食物5
	[]
	当前的食物6
	['撞羊']
	当前的食物7
	[]
	当前的食物8
	['撞羊']
	当前的食物9
	[]
	程序运行结束的[]的唯一标识符486994311240

额外的发现

为什么上述程序中还要一段关于a和b列表的程序呢，因为观察程序运行结束的[]和a和b的内存地址，可以发现：他们居然是一样的。都是486994311304

所这里又发现了一个现象，也不太明白原理(有了解的大佬可以评论处告诉我)：

python似乎始终对列表预留了一个内存地址，使用(赋给其他变量)之后，又开了一个新的内存地址.

总结

  1. 类变量形参千万不能将可变类型作为默认值。否则使用实例将共享这个形参提供的内容地址
  2. 类的代码在程序加载时，其中除函数内部的代码块，其他部分是会运行的
  3. python对变量进行赋值时，不管是可变数据类型还是不可变数据类型，一开始引用的都是同一内存地址，而不可变数据类型重新赋值或运算后会指向新的内存地址，而可变类型却仅是改变了所指向内存地址中的值。
  4. python似乎始终对列表预留了一个内存地址，将其使用(赋给其他变量)之后，又开了一个新的内存地址.(这个就很诡异…)
月司
关注
专栏目录
python：__init__( )方法
不怕猫的耗子A
06-17 1万+
python魔法方法：__init__( ) 1、__init__()方法称为构造方法，__init__()方法的魔力体现在只要实例化一个对象，这个方法就会在对象被创建时自动调用。 2、实例化对象时是可以传入参数的，这些参数会自动传入__init__()方法中，可以通过重写这个方法来自定义对象的初始化操作 总结：__init__()方法是一个特殊的方法，在对象实例化时会被调用，__ini...
python创建一个类的实例_创建一个简单的类的实例教程
weixin_34665990的博客
02-20 1347
class Dog():"""一次模拟小狗的简单尝试"""def __init__(self, name, age):"""初始化属性name和age"""self.name = nameself.age = agedef sit(self):"""模拟小狗被命令时蹲下"""print(self.name.title() + " now is sitting.")def roll_over(sel...
python从入门到实践第九章答案_《Python编程从入门到实践》_第九章_类
weixin_39609483的博客
12-04 501
classDog():"""一次模拟小狗的简单尝试"""def __init__(self, name, age):"""初始化属性name和age"""self.name=nameself.age=agedefsit(self):"""模拟小狗被命令时蹲下"""print(self.name.title() + "now is sitting.")defroll_over(self):"""模拟...
当我的类包含带有默认值且在Python中具有更多参数的init方法时出现错误
04-05
Python不支持多个构造函数（__init__）。您可以创建一个具有可选参数和拆分功能的类... Employee类：def __init __（self，workingHrs = None）：如果workingHrs为None：print（'这是init方法'）else ：print（'这是具有...的初始化方法
python：给类的属性指定默认值
最新发布
听海边涛声
02-02 460
python：给类的属性指定默认值
陷阱！python参数默认值
01-04 552
原文地址 在stackoverflow上看到这样一个程序： #! /usr/bin/env python # -*- coding: utf-8 -*- class demo_list: def __init__(self, l=[]): self.l = l def add(self, ele): self.l.append
Python 中默认参数的特性
qq_29827369的博客
05-02 709
在Python中默认参数只会别求值一遍，然后记录下这个值，以后每次调用这个方法或者是函数的时候都会传递这个求值一遍的默认值，如果这个默认参数的值是一个不可变的值，没什么问题，但是当这个默认参数的值是一个可变的值，就会触发一些意想不到的Bug. 代码如下： class Player(object): def __init__(self,name,items=[]): self.name = name self.items = items player_a = P
Python进阶-函数默认参数
dengjuan7930的博客
05-17 392
Python进阶-函数默认参数 写在前面 如非特别说明，下文均基于Python3 一、默认参数 python为了简化函数的调用，提供了默认参数机制： def pow(x, n = 2): r = 1 while n > 0: r *= x n -= 1 return r 这样在调用pow函数时，就可以省略最后一个参数不写...
【笔记】python中使用类和实例：Car类、给属性指定默认值、修改属性的值（直接修改属性的值、通过方法修改属性的值、通过方法对属性的值进行递增）
qq_51843109的博客
03-27 4584
文章目录一、使用类和实例1.Car类2.给属性指定默认值3.修改属性的值（1）直接修改属性的值（2）通过方法修改属性的值（3）通过方法对属性的值进行递增 一、使用类和实例 1.Car类 2.给属性指定默认值 3.修改属性的值 （1）直接修改属性的值 （2）通过方法修改属性的值 （3）通过方法对属性的值进行递增 ...
python形参和实参命名方式_Python的形参和实参使用方式
weixin_39595621的博客
12-15 2405
Python的形参和实参使用方式形参可以设置参数默认值，设置遵循从右至左原则例如：fun(x=0,y=1),fun(x,y=1)，但不可以是fun(x=1,y)形参设置可以为数字字符串变量、元组和字典等任意类型数据，元组形参是在变量名前加*，字典形参是在变量名前加**例如：fun(var),fun(*tuple),fun(*list),fun(**dict)实参接受也可以是任意类型数据，当接收数据...
python编写一个汽车类_Python 类：以汽车为例
weixin_39553805的博客
11-29 4503
class Car():def __init__(self,make,model,year):'''以self为前缀的变量都可供类中的所有方法使用，还可以通过类的任何实例来访问这些变量。可以将self理解为制作原料，方法为制作图纸。用户只需要传入数据，python会自动利用原料self和图纸制作出用户想要的“实例”。'''#初始化属性（以下四行）self.make = makeself.model...
python类方法第一个参数_你能在python类的__init__中使用静态方法作为默认参数吗?(Can you use a static method as default parameter i...
weixin_39550486的博客
11-25 109
The reason you’re having problems with your static method usage as a default argument is due to a combination of two issues.The first issue is that the default argument needs to be well defined when t...
python函数默认参数_Python中函数的默认参数问题
weixin_39623713的博客
12-03 220
前几天，运营反馈了一个BUG，某些数据在写入数据库后，其时间字段出现异常，与当前时间相差较多。由于代码是不是我写的，所以开始一遍阅读代码一遍排查问题。在主流程中，仅仅发现了一个对时间赋值的语句，并且赋值使用的是data.CreateTime=int(time.time())这样的形式，应该没有问题。在别的地方没有找到对该字段赋值的操作，于是想看看这个类是不是自身有什么方法会修改时间字段。最终在类初...
python 类基本写法－默认方法ｉｎｉｔ
deep learning
09-06 980
class Animal: # default constructor def __init__(self): self.dog = "bulldog" # a method for printing data members def print_dog(self): print(self.dog) # creating object of the class obj = Animal() # ca
python继承 子类init_Python类继承：使用自己的和父的默认值和init方法进行动态子类初始化...
weixin_28928727的博客
01-15 360
我试图创建一个类系统，这些类可以用**kwargs初始化，并且每个字段都有默认值。下面是一些代码，表示我要做的事情：class Parent(object): #should only have p_var fieldsDEFAULTS = {"p_var_1" : "my name","p_var_2" : 2}def __init__(self, **kwargs):for key in DE...
python函数默认值的坑
qq_39499407的博客
11-12 133
关键字：python、函数默认值、init函数默认值python中，如果函数的参数带有默认参数，那么它在“编译时”就确定了值，之后无论怎么改变，形参的默认值都是最初的。
python学习笔记（六）——类的初始化(__init__)、类属性和类方法 和 对象
热门推荐
小曾同学的博客
08-16 1万+
学习本篇文章后会了解到：类的创建，为对象添加属性，对象的初始化，自定义对象的输出，类属性和类方法的创建。 1. 类的定义与格式 类是对一群具有相同特征或者行为的事物的一个统称。 类是一个模块，是负责创建对象的。 类的命名采用大驼峰命名法。 类中的特征称为属性，行为称为方法 格式： class 类名： def 方法1(self,参数列表): pass d...
python默认参数的一个注意事项
肥仔的博客
02-27 683
我们来看一下以下的函数： >>> def add_end(L=[]): ... L.append('end') ... return L ... 正常调用时结果似乎并没有错： 但是使用默认参数调用时会发现似乎每次都记住了上次添加后的list： 原因是默认参数也是一个变量，它指向对象[]，每次调用这个函数，如果改变了L的内容，则下次调用时，默认参数的内容就变了...
Python函数默认参数为空列表
铁头同学的博客
08-30 1327
Python函数默认参数为空列表
python 类内函数 使用类成员做形参默认值
05-13
在 Python 中，可以使用类成员作为函数的默认参数。这可以通过在函数定义中使用类名来实现。例如，假设我们有一个名为 MyClass 的类，其中包含一个成员变量 my_var： ``` class MyClass: def __init__(self): ...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

月司

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值