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):
        pass

with与“上下文管理器”

# 普通版，此部分有一个潜在问题，即如果在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")