Python（黄金时代）—— python深入使用
深拷贝和浅拷贝
可变类型与不可变类型
-
可变对象是指，一个对象在不改变其引用的前提下，可以修改其所指向的地址中的值
-
不可变对象是指，一个对象引用指向的值是不能修改的
浅拷贝
-
浅拷贝是对于一个对象的顶层拷贝；
-
简单理解就是，拷贝了引用，并没有拷贝内容
-
这也就意味着，只要修改其中一个引用的内容，其它引用的地方也都会改变
深拷贝
-
会拷贝引用指定的值，放入新生成的内存空间中
-
引用也会重新生成
示例
import copy
# 浅拷贝
a=[1,3]
b=a
a.append(4)
# 引用地址一样，操作其中一个引用添加数据，另一个也会变
print("浅拷贝..............")
print(id(a))
print(id(b))
print(a)
print(b)
# 深拷贝
c=[1,3]
d=copy.deepcopy(c)
c.append(4)
# 引用不一样了，利用其中一个修改了值，另一个不会改变
print("深拷贝..............")
print(id(c))
print(id(d))
print(c)
print(d)输出结果
总结：不管是浅拷贝还是深拷贝都会生成一个看起来相同的对象，他们本质的区别是拷贝出来的对象的地址是否和原对象一样，也就是地址的复制还是值的复制的区别
私有化、import、面向对象
方法私有化
-
xx：公有变量
-
_x： 单前置下划线，私有化属性或方法,类对象和子类可以访问，但禁止导入
-
__xx：双前置下划线，避免与子类中的属性命名冲突，无法在外部直接访问
-
__xx__：双前后下划线，用户名字空间的魔法对象或属性。例如：__init__
-
xx_：单后置下划线，用于避免与Python关键词冲突
示例
class Test:
# 初始化方法
def __init__(self,name,age,sex):
# 公有变量
self.name=name
# 私有化属性
self._age=age
# 外部无法直接访问
self.__sex=sex
def show(self):
print(self.name)
print(self._age)
print(self.__sex)
test=Test("as",12,"男")
test.show()import 导入模块
-
import 搜索路径
-
从下面列出的目录里面依次查找要导入的模块文件
-
'' 表示当前路径
-
列表中路径的先后顺序代表了 python 解释器在搜索模块时的先后顺序
-
-
程序添加路径
-
sys.path.append() 在末尾添加路径
-
sys.path.insert() 在指定位置插入路径
-
类方法类型
方法包括：实例方法、静态方法和类方法，三种方法在内存中都归属于类，区别在于调用方式不同
-
实例方法：由对象调用，至少有一个self参数，执行实例方法时，自动将调用该方法的对象赋值给self
-
类方法：由类调用，至少一个cls参数，执行类方法时，自动将调用该方法的类赋值给cls
-
静态方法：由类直接调用，可以没有任何参数
-
property方法： 一种与实例方法相似的特殊方法，使用方法如下
-
定义时，在实例方法上加 @property 注解,并只有 self一个参数
-
调用时，无需括号
-
property 有三种访问方式，分别对应三个被 @property、@方法名.setter、@方法名.deleter 修饰的方法
-
示例
class Test:
age =12
def __init__(self,name):
self.name=name
def instance_method(self):
"""实例方法，至少有一个self参数"""
print("这是实例方法,name值是：",self.name)
@classmethod
def class_method(cls,age):
"""类方法，至少有一个cls参数"""
cls.age=age
print("这是类方法,age值是：",cls.age)
@staticmethod
def static_method():
"""这是静态方法，可以没有任何参数"""
print("这是静态方法")
@property
def count(self):
"""这是property特殊属性"""
return 11
@count.setter
def count(self,value):
print("property设置值为：",value)
@count.deleter
def count(self):
print("property删除")
test=Test("张三")
#调用实例方法
test.instance_method()
#调用类方法
Test.class_method(22)
# 调用静态方法
Test.static_method()
# 调用property方法
aa=test.count
print(aa)
test.count=44
del test.count输出结果
property的第二种用法
class Test2:
def get_count(self):
return 22
def set_count(self,value):
print("设置值:",value)
def del_count(self):
print("删除值")
# property 方法有四个参数
# 第一个参数是方法名，调用对象.属性 时执行方法
# 第二个参数是方法名, 调用对象.属性 = XXX 时，执行方法
# 第三个参数是方法名，调用 del 对象.属性 时，执行方法
# 第四个参数是字符串，调用 对象.属性.__doc__ ，此参数是该属性的描述信息
cc=property(get_count,set_count,del_count,"ssssssss")
test2=Test2()
c=test2.cc
print(c)
test2.cc=444
del test2.cc
doc=test2.cc.__doc__
print(doc)输出结果
魔法属性
__doc__ 表示类的描述信息
class Tee:
""" 描述类的信息 ,xxxxxxxxxxxxxxxxxxxxxx"""
def __init__(self):
pass
print(Tee.__doc__)输出结果
__module__ 和 __class__
-
__module__ 表示当前操作的对象在哪个模块
-
__class__ 表示当前操作的对象类是什么
class Dog:
def __init__(self,name):
self.name=name
dog=Dog("小白")
print(dog.__module__)
print(dog.__class__)输出结果
__init__
-
初始化方法：通过类创建对象时，自动触发执行
class Dog:
def __init__(self,name):
self.name=name
dog=Dog("小白")__del__
-
当对象在内存中被释放时，自动触发执行
-
此方法一般不用定义，程序员在使用时无需关心内存的分配和释放，Python解释器会自动执行，所以 __del__ 的调用是由解释器在进行垃圾回收时自动触发执行
class Dog:
def __del__(self):
passwith与“上下文管理器”
# 普通版，此部分有一个潜在问题，即如果在write时发生异常，则close不会被调用，资源将得不到释放
def t1():
f=open("aa.txt","w")
f.write("hello world!")
f.close()
# 升级版本, 此处可以保证发生异常时，资源能得到释放. 但是代码写得比较复杂
def t2():
f = open("aa.txt", "w")
try:
f.write("hello world!")
except Exception as e:
print("发生错误!!")
finally:
f.close()
# 高级版,此处使用 with的作用和使用 try/finally 语句是一样的，并且写法更简洁
def t3():
with open("aa.txt", "w") as f:
f.write("hello world!")什么是上下文
-
上下文在不同的地方表示不同的含义，与文章的上下文含义一样。
上下文管理器
-
任何实现了 __enter__ 和 __exit__ 方法的对象都可以称为上下文管理器，上下文管理器可以使用 with 关键字。文件（file） 对象也实现了上下文管理器
示例
# 自定义一个文件类,作为上下文管理器
class MyFile:
def __init__(self,filename,mode):
self.filename=filename
self.mode=mode
# 返回资源对象
def __enter__(self):
self.f=open(self.filename,self.mode)
return self.f
# 处理一些清除工作
def __exit__(self, exc_type, exc_val, exc_tb):
self.f.close()
with MyFile("aa.txt","w") as f:
f.write("sssssss")