深拷貝和淺拷貝

可變類型與不可變類型

• 可變對象是指，一個對象在不改變其引用的前提下，可以修改其所指向的地址中的值
• 不可變對象是指，一個對象引用指向的值是不能修改的

淺拷貝

• 淺拷貝是對于一個對象的頂層拷貝；
• 簡單理解就是，拷貝了引用，并沒有拷貝內容
• 這也就意味著，只要修改其中一個引用的內容，其它引用的地方也都會改變

深拷貝

• 會拷貝引用指定的值，放入新生成的內存空間中
• 引用也會重新生成

**示例

**

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")