网站设计的研究方法有哪些,广州注册公司补贴,dedecmsv5.6 qq空间网站模板,网站关键词几个字文章目录8.1变量不是盒子8.2 标识,相等性和别名8.2.1 在和is之间选择8.2.2 元组的相对不可变性8.3 默认做浅复制#xff08;拓展#xff09;为任意对象做深复制和浅复制深拷贝和浅拷贝有什么具体的区别呢#xff1f;8.4 函数的参数作为引用时8.4.1 不要使用可变类型作为参数…
文章目录8.1变量不是盒子8.2 标识,相等性和别名8.2.1 在和is之间选择8.2.2 元组的相对不可变性8.3 默认做浅复制拓展为任意对象做深复制和浅复制深拷贝和浅拷贝有什么具体的区别呢8.4 函数的参数作为引用时8.4.1 不要使用可变类型作为参数的默认值总结(阅读)8.4.2 防御可变参数8.5 del和垃圾回收8.6 弱引用8.1变量不是盒子
python变量类似于Java中的引用型变量,因此最好把他们理解为附注在对象上的标注.
a [1,2,3]
b a
a.append(7)
print(b)输出为:
[1, 2, 3, 7]
// 可以发现,a和b引用同一个列表,而不是那个列表的副本因为变量只不过是标注,所以可以为对象贴上多个标注,贴的多个标注就是别名.
8.2 标识,相等性和别名
每个变量都有标识,类型和值.对象一旦创建,它的标识一定不会变;可以把标识ID理解为对象在内存中的地址. is运算符比较两个对象的标识; id()函数返回对象标识的整数表示.
标识最常使用is运算符检查,而不是直接比较ID.
charles {name:charles, born:1832}
lewis charles
print(lewis is charles)
print(id(charles), id(lewis))
lewis[balence] 950
print(charles)
alex {name: charles, born: 1832, balence: 950}
print(alex charles)
print(alex is charles)输出:
True
140640659352168 140640659352168
{name: charles, born: 1832, balence: 950}
True //比较两个对象,结果相同,这是因为dic类的__eq__方法就是这样实现的
False //但是他们是不同的对象,标识不同.
//可以发现,charles和lewis绑定同一个对象,alex绑定另外一个对象8.2.1 在和is之间选择
运算符比较两个对象的值(对象中保存的数据),而is比较对象的标识标识就是在内存中的位置 在变量和单例值之间比较时,应该使用is.可以使用is检查变量绑定的值是不是None. x is Noneis 运算符比 速度快因为它不能重载所以 Python 不用寻找并调用特殊方法而是直接比较两个整数 ID。而 a b 是语法糖等同于 a.eq(b)。继承自 object 的__eq__ 方法比较两个对象的 ID结果与 is 一样。但是多数内置类型使用更有意义的方式覆盖了 eq 方法会考虑对象属性的值。相等性测试可能涉及大量处理工作。
8.2.2 元组的相对不可变性
元组与多数 Python 集合列表、字典、集等等一样保存的是对象的引用。而 str、bytes 和 array.array 等单一类型序列是扁平的它们保存的不是引用而是在连续的内存中保存数据本身字符、字节和数字。 元组的不可变性其实是指tuple数据结构的物理内容(保存的引用)不可变,与引用的对象无关. 复制对象时相等性和一致性之间的区别有更深入的影响。副本与源对象相等但是ID不同。可是如果对象中包含其他对象那么应该复制内部对象吗可以共享内部对象吗这些问题没有唯一的答案。
8.3 默认做浅复制
l1 [3, [55, 44], (7, 8, 9)]
l2 list(l1)
print(l2)
print(l2 l1)
print(l2 is l1)
print(l2[2] is l1[2])
l3 l1[:]
print(l3)
print(l3 l1)
print(l3 is l1)
print(l3[2] is l1[2])
l4 l1
print(l4 l1)
print(l4 is l1)
l1[1].append(66)
print(l1)
print(l2)
print(l3)
print(l4)输出结果如下: 上图发现
l2和l3对应着关于l1的浅拷贝l4直接将l1起了一个别名也就是说l4和l1指向了同一个对象。浅拷贝对于内层引用有影响即内层引用还是指向了同一个对象。[3, [55, 44], (7, 8, 9)] //list(l1)创建l1的副本 True //副本和源列表相等
对于列表和其他可变序列来说,还可以使用更简洁的l3 l1[:]语句来创建副本 然而,构造方法或者[:] 做的是浅复制(就是复制了最外层容器,副本中的元素是源容器中元素的引用).如果所有的元素都是不可变的,那么这样没有问题,如果有可变的元素,会出现问题. l1 [3,[66,55,44],(7,8,9)]
l2 list(l1)
l1.append(100)
l1[1].remove(55)
print(l1:,l1)
print(l2:,l2)
l2[1][33,22]
l2[2](10,11)
print(l1:,l1)
print(l2:,l2)输出:
l1: [3, [66, 44], (7, 8, 9), 100]
l2: [3, [66, 44], (7, 8, 9)]
l1: [3, [66, 44, 33, 22], (7, 8, 9), 100]
l2: [3, [66, 44, 33, 22], (7, 8, 9, 10, 11)]
# 对**元组**来说,运算符创建一个新元组,然后重新绑定给变量l2[2].现在l1和l2中最后位置上的元组不是同一个对象.
# 总结对和×所做的增量赋值来说如果左边的变量绑定的是不可变对象会创建新对象如果是可变对象会就地修改。如图
拓展为任意对象做深复制和浅复制
浅复制没什么问题但有时我们需要的是深复制即副本不共享内部对象的引用。
import copy
class Bus:def __init__(self, passengersNone):if passengers is None:self.passengers []else:self.passengers passengersdef pick(self,name):self.passengers.append(name)def drop(self,name):self.passengers.remove(name)
bus1 Bus([Alice, Bill, Claire, David])
bus2 copy.copy(bus1)
bus3 copy.deepcopy(bus1)
print(id(bus1), id(bus2), id(bus3))
bus1.drop(Bill)
print(bus2.passengers)
print(id(bus1.passengers), id(bus2.passengers),id(bus3.passengers))
print(bus3.passengers)输出:
140694379943920 140694379943976 140694379944088
[Alice, Claire, David]
140694377362824 140694377362824 140694377336776
[Alice, Bill, Claire, David]结果如图 使用 copy 和 deepcopy创建 3 个不同的 Bus 实例。 审查 passengers 属性后发现
bus1 和 bus2 共享同一个列表对象因为 bus2 是bus1 的浅复制副本。bus3 是 bus1 的深复制副本因此它的 passengers 属性指代另一个列表。 从上面可以发现深拷贝和浅拷贝都会创建不同的对象深拷贝是完全拷贝一个新的对象浅拷贝不会拷贝子对象。
深拷贝和浅拷贝有什么具体的区别呢
import copy
a [1,2,3,[a,b,c]]
b copy.copy(a)
c copy.deepcopy(a)
a[3].append(d)
print(a)
print(b)
print(c)结果如图 从上图我们可以发现
copy.deepcopy()会完全拷贝一个新的对象出现copy.copy()不会拷贝其子对象也就是说如果原来的对象里面又包含别的对象的引用则这个新的对象还是会指向这个旧的内层引用。 总结 copy.copy() 浅复制不会拷贝其子对象修改子对象将受影响 . copy.deepcopy() 深复制将拷贝其子对象修改子对象将不受影响.
8.4 函数的参数作为引用时
python唯一支持的参数传递模式是共享传参(call by sharing). 共享传参指函数的各个形式参数获得实参中各个引用的副本,也就是说,函数内部的形参是实参的别名。 这种方案的结果是函数可能会修改作为参数传入的可变对象但是无法修改那些对象的标识即不能把一个对象替换成另一个对象。
def f(a,b):a breturn a
x,y 1,2
print(f(x, y))
print(x, y)
a [1, 2]
b [3, 4]
print(f(a, b))
print(a, b)
t (10, 20)
u (30, 40)
print(f(t, u))
print(t, u)输出
3
1 2
[1, 2, 3, 4]
[1, 2, 3, 4] [3, 4]
(10, 20, 30, 40)
(10, 20) (30, 40)我们发现数字x没变,列表a变了,元组t没变
8.4.1 不要使用可变类型作为参数的默认值
可选参数可以有默认值,这是python函数定义的一个很好的特性.但是我们应该避免使用可变的对象作为参数的默认值.
class HauntedBus:备受幽灵乘客折磨的校车def __init__(self, passengers[]):self.passengers passengersdef pick(self,name):self.passengers.append(name)def drop(self,name):self.passengers.remove(name)bus1 HauntedBus([Alice,Bill])
print(bus1.passengers)
bus1.pick(Charlie)
bus1.drop(Alice)
print(bus1.passengers)
bus2 HauntedBus()
bus2.pick(Carrie)
print(bus2.passengers)
bus3 HauntedBus()
print(bus3.passengers)
bus3.pick(Dive)
print(bus2.passengers)
print(bus2.passengers is bus3.passengers)
print(bus1.passengers)输出
[Alice, Bill]
[Bill, Charlie]
[Carrie]
[Carrie]//bus3一开始是空的但是默认列表却不为空
[Carrie, Dive]
True
[Bill, Charlie]问题在于没有指定初始乘客的HauntedBus实例会共享同一个乘客列表。 使用可变类型作为函数参数的默认值有危险因为如果就地修改了参数默认值也就变了这样会影响以后使用默认值的调用。 修正的方法很简单在__init__方法中传入passengers参数时应该把参数值的副本赋值给self.passengers,
def __init__(self,passengers None):if passengers is None:self.passengers []else:self.passengers list(passengers)总结(阅读)
关于和extend()方法是创建了新对象extend是就地连接。浅复制分为两类 第一类t2 t1[:]或者 t2 list(t1) 都是了新的对象t2.但是内层引用还是指向同一个对象。第二类l2 copy.copy(l1) 深复制: l3 copy.deepcopy(l1) 完全拷贝了一个新的对象。关于增量运算符和×以为例ab若前面的a为可变序列(例如list)则就地解决若a为不可变序列(例如tuple)则会创建新的对象。实例中图片经过:http://www.pythontutor.com/ 生成
8.4.2 防御可变参数
如果定义的函数接收可变参数应该谨慎考虑调用方是否期望修改传入的参数。 示例 8-15 一个简单的类说明接受可变参数的风险
class TwilightBus:让乘客销声匿迹的校车def __init__(self, passengersNone):if passengers is None:self.passengers []else:self.passengers passengers def pick(self, name):self.passengers.append(name)def drop(self, name):self.passengers.remove(name)测试一下 basketball_team [Sue, Tina, Maya, Diana, Pat] bus TwilightBus(basketball_team) bus.drop(Tina) bus.drop(Pat)basketball_team
[Sue, Maya, Diana]发现下车的学生从篮球队中消失了 TwilightBus 违反了设计接口的最佳实践即“最少惊讶原则”。学生从校车中下车后她的名字就从篮球队的名单中消失了这确实让人惊讶。
这里的问题是校车为传给构造方法的列表创建了别名。正确的做法是校车自己维护乘客列表。修正的方法很简单在 init 中传入 passengers 参数时应该把参数值的副本赋值给 self.passengers像示例 8-8 中那样做8.3 节。
def __init__(self, passengersNone):
if passengers is None:self.passengers []
else:self.passengers list(passengers) ➊➊ 创建 passengers 列表的副本如果不是列表就把它转换成列表。在内部像这样处理乘客列表就不会影响初始化校车时传入的参数了。此外这种处理方式还更灵活现在传给 passengers 参数的值可以是元组或任何其他可迭代对象例如set 对象甚至数据库查询结果因为 list 构造方法接受任何可迭代对象。
8.5 del和垃圾回收
del 语句删除名称而不是对象。del 命令可能会导致对象被当作垃圾回收但是仅当删除的变量保存的是对象的最后一个引用或者无法得到对象时。 重新绑定也可能会导致对象的引用数量归零导致对象被销毁。
在 CPython 中垃圾回收使用的主要算法是引用计数。实际上每个对象都会统计有多少引用指向自己。当引用计数归零时对象立即就被销毁CPython 会在对象上调用__del__ 方法如果定义了然后释放分配给对象的内存。 CPython 2.0 增加了分代垃圾回收算法用于检测引用循环中涉及的对象组——如果一组对象之间全是相互引用即 使再出色的引用方式也会导致组中的对象不可获取。Python 的其他实现有更复杂的垃圾回收程序而且不依赖引用计数这意味着对象的引用数量为零时可能不会立即调用__del__ 方法。
8.6 弱引用
正是因为有引用对象才会在内存中存在。当对象的引用数量归零后垃圾回收程序会把对象销毁。但是有时需要引用对象而不让对象存在的时间超过所需时间。这经常用在缓存中。 弱引用不会增加对象的引用数量。引用的目标对象称为所指对象referent。因此我们说弱引用不会妨碍所指对象被当作垃圾回收。 弱引用在缓存应用中很有用因为我们不想仅因为被缓存引用着而始终保存缓存对象。
