python中復(fù)制函數(shù) Python復(fù)制

python123考試模式怎么復(fù)制

在python中用有一個模塊可以用來處理剪切板復(fù)制的內(nèi)容，pyperclip模塊

創(chuàng)新互聯(lián)公司是一家專注于成都做網(wǎng)站、成都網(wǎng)站建設(shè)與策劃設(shè)計,源匯網(wǎng)站建設(shè)哪家好?創(chuàng)新互聯(lián)公司做網(wǎng)站,專注于網(wǎng)站建設(shè)10多年,網(wǎng)設(shè)計領(lǐng)域的專業(yè)建站公司;建站業(yè)務(wù)涵蓋:源匯等地區(qū)。源匯做網(wǎng)站價格咨詢:028-86922220

pyperclip模塊有copy()和paste()函數(shù)，分別用于向計算機的剪貼板發(fā)送文本，或從它接受文本。

pyperclip模塊不是python自帶的。所以要安裝這個模塊，例如 pip install pyperclip

下面就這個模塊的使用簡單舉例：

1.例題1

創(chuàng)建一個文件用來存儲你的多個賬戶的密碼應(yīng)用： (假設(shè)創(chuàng)建的py文件名為 ：pw.py)

#！python3

PASSWORDS = {'email':'adjofahoweghowaehgg',

'blog':'GEAGefwegEgeghfewEGEege呵呵跟了猴哥hhaji',

'luggage':'12345'}

import sys,pyperclip

if len(sys.argv) 2:

print('請輸入：py pw.py 帳號名 -以確認(rèn)用于查詢相應(yīng)的密碼')

sys.exit()

account = sys.argv[1]

if account in PASSWORDS:

pyperclip.copy(PASSWORDS[account])

print('Password for ' + account + ' 已經(jīng)復(fù)制，請粘貼使用')

else:

print('系統(tǒng)中無此賬戶的記錄')

運行如下：

python pw.py blog

Password for blog已經(jīng)復(fù)制，請粘貼使用

運行程序后，內(nèi)容已經(jīng)自動到你的電腦的剪貼板上面，你直接粘貼使用即可；這種方法可以用于管理你的賬戶密碼，無論設(shè)置多復(fù)雜的密碼都不用擔(dān)心記不住，直接粘貼使用即可；

例題2：

上面例題有提到對剪貼板內(nèi)容的復(fù)制和粘貼，但有的時候我們復(fù)制的內(nèi)容，我們想對復(fù)制的內(nèi)容添加進去我們自己想要設(shè)定的東西，下面我們用例題來分析：

例如，我們在電腦上面復(fù)制了一段文本，內(nèi)容如下：

List of animals

Lists of aquarium life

Lists of biologists by author abbreviation

List of cultivars

我們想要在這段文本的每行前面都加上一個‘*’號

代碼：

#！python3

import pyperclip

text = pyperclip.paste() #將我們已經(jīng)復(fù)制到電腦剪貼板準(zhǔn)備粘貼的內(nèi)容 賦給text

lines = text.split('\n') #split()方法用于指定以某個字符來分割字符串 例如：spam = "hello i'm peter" spam.split("'") 輸出的是：['hello i', 'm peter']

for i in range(len(lines)):

lines[i] = '*' + lines[i]

text = '\n'.join(lines) #lines 通過處理出來是一個字符列表，而text是需要一個字符串，因此需要用到j(luò)oin來連接各列表中的各字符串

pyperclip.copy(text)

#join方法 在一個字符串上調(diào)用，參數(shù)是一個字符串列表，返回一個字符串。返回的字符串由傳入的列表中每個字符串連接而成。

如: ','.join['cats','rats','bats']

out:'cats,rats,bats'

' 'join['cats','rats','bats']

out: 'cat rats bats'

python字典操作函數(shù)

字典是一種通過名字或者關(guān)鍵字引用的得數(shù)據(jù)結(jié)構(gòu)，其鍵可以是數(shù)字、字符串、元組，這種結(jié)構(gòu)類型也稱之為映射。字典類型是Python中唯一內(nèi)建的映射類型，基本的操作包括如下：

(1)len()：返回字典中鍵—值對的數(shù)量；

(2)d[k]:返回關(guān)鍵字對于的值；

(3)d[k]=v:將值關(guān)聯(lián)到鍵值k上；

(4)del d[k]:刪除鍵值為k的項；

(5)key in d:鍵值key是否在d中，是返回True，否則返回False。

(6)clear函數(shù)：清除字典中的所有項

(7)copy函數(shù)：返回一個具有相同鍵值的新字典；deepcopy()函數(shù)使用深復(fù)制，復(fù)制其包含所有的值，這個方法可以解決由于副本修改而使原始字典也變化的問題

(8)fromkeys函數(shù)：使用給定的鍵建立新的字典，鍵默認(rèn)對應(yīng)的值為None

(9)get函數(shù)：訪問字典成員

(10)has_key函數(shù)：檢查字典中是否含有給出的鍵

(11)items和iteritems函數(shù):items將所有的字典項以列表方式返回，列表中項來自（鍵，值），iteritems與items作用相似，但是返回的是一個迭代器對象而不是列表

(12)keys和iterkeys：keys將字典中的鍵以列表形式返回，iterkeys返回鍵的迭代器

(13)pop函數(shù)：刪除字典中對應(yīng)的鍵

(14)popitem函數(shù)：移出字典中的項

(15)setdefault函數(shù)：類似于get方法，獲取與給定鍵相關(guān)聯(lián)的值，也可以在字典中不包含給定鍵的情況下設(shè)定相應(yīng)的鍵值

(16)update函數(shù)：用一個字典更新另外一個字典

(17)?values和itervalues函數(shù)：values以列表的形式返回字典中的值，itervalues返回值得迭代器，由于在字典中值不是唯一的，所以列表中可以包含重復(fù)的元素

一、字典的創(chuàng)建

1.1 直接創(chuàng)建字典

d={'one':1,'two':2,'three':3}

printd

printd['two']

printd['three']

運算結(jié)果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':3,'two':2,'one':1}

1.2 通過dict創(chuàng)建字典

# _*_ coding:utf-8 _*_

items=[('one',1),('two',2),('three',3),('four',4)]

printu'items中的內(nèi)容:'

printitems

printu'利用dict創(chuàng)建字典，輸出字典內(nèi)容:'

d=dict(items)

printd

printu'查詢字典中的內(nèi)容:'

printd['one']

printd['three']

運算結(jié)果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

items中的內(nèi)容:

[('one',1), ('two',2), ('three',3), ('four',4)]

利用dict創(chuàng)建字典，輸出字典內(nèi)容:

{'four':4,'three':3,'two':2,'one':1}

查詢字典中的內(nèi)容:

或者通過關(guān)鍵字創(chuàng)建字典

# _*_ coding:utf-8 _*_

d=dict(one=1,two=2,three=3)

printu'輸出字典內(nèi)容:'

printd

printu'查詢字典中的內(nèi)容:'

printd['one']

printd['three']

運算結(jié)果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

輸出字典內(nèi)容:

{'three':3,'two':2,'one':1}

查詢字典中的內(nèi)容:

二、字典的格式化字符串

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3,'four':4}

printd

print"three is %(three)s."%d

運算結(jié)果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'four':4,'three':3,'two':2,'one':1}

threeis3.

三、字典方法

3.1?clear函數(shù)：清除字典中的所有項

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3,'four':4}

printd

d.clear()

printd

運算結(jié)果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'four':4,'three':3,'two':2,'one':1}

{}

請看下面兩個例子

3.1.1

# _*_ coding:utf-8 _*_

d={}

dd=d

d['one']=1

d['two']=2

printdd

d={}

printd

printdd

運算結(jié)果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'two':2,'one':1}

{}

{'two':2,'one':1}

3.1.2

# _*_ coding:utf-8 _*_

d={}

dd=d

d['one']=1

d['two']=2

printdd

d.clear()

printd

printdd

運算結(jié)果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'two':2,'one':1}

{}

{}

3.1.2與3.1.1唯一不同的是在對字典d的清空處理上，3.1.1將d關(guān)聯(lián)到一個新的空字典上，這種方式對字典dd是沒有影響的，所以在字典d被置空后，字典dd里面的值仍舊沒有變化。但是在3.1.2中clear方法清空字典d中的內(nèi)容，clear是一個原地操作的方法，使得d中的內(nèi)容全部被置空，這樣dd所指向的空間也被置空。

3.2?copy函數(shù)：返回一個具有相同鍵值的新字典

# _*_ coding:utf-8 _*_

x={'one':1,'two':2,'three':3,'test':['a','b','c']}

printu'初始X字典：'

printx

printu'X復(fù)制到Y(jié)：'

y=x.copy()

printu'Y字典：'

printy

y['three']=33

printu'修改Y中的值，觀察輸出：'

printy

printx

printu'刪除Y中的值，觀察輸出'

y['test'].remove('c')

printy

printx

運算結(jié)果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

初始X字典：

{'test': ['a','b','c'],'three':3,'two':2,'one':1}

X復(fù)制到Y(jié)：

Y字典：

{'test': ['a','b','c'],'one':1,'three':3,'two':2}

修改Y中的值，觀察輸出：

{'test': ['a','b','c'],'one':1,'three':33,'two':2}

{'test': ['a','b','c'],'three':3,'two':2,'one':1}

刪除Y中的值，觀察輸出

{'test': ['a','b'],'one':1,'three':33,'two':2}

{'test': ['a','b'],'three':3,'two':2,'one':1}

注：在復(fù)制的副本中對值進行替換后，對原來的字典不產(chǎn)生影響，但是如果修改了副本，原始的字典也會被修改。deepcopy函數(shù)使用深復(fù)制，復(fù)制其包含所有的值，這個方法可以解決由于副本修改而使原始字典也變化的問題。

# _*_ coding:utf-8 _*_

fromcopyimportdeepcopy

x={}

x['test']=['a','b','c','d']

y=x.copy()

z=deepcopy(x)

printu'輸出：'

printy

printz

printu'修改后輸出：'

x['test'].append('e')

printy

printz

運算輸出：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

輸出：

{'test': ['a','b','c','d']}

{'test': ['a','b','c','d']}

修改后輸出：

{'test': ['a','b','c','d','e']}

{'test': ['a','b','c','d']}

3.3?fromkeys函數(shù)：使用給定的鍵建立新的字典，鍵默認(rèn)對應(yīng)的值為None

# _*_ coding:utf-8 _*_

d=dict.fromkeys(['one','two','three'])

printd

運算輸出：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':None,'two':None,'one':None}

或者指定默認(rèn)的對應(yīng)值

# _*_ coding:utf-8 _*_

d=dict.fromkeys(['one','two','three'],'unknow')

printd

運算結(jié)果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':'unknow','two':'unknow','one':'unknow'}

3.4?get函數(shù)：訪問字典成員

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3}

printd

printd.get('one')

printd.get('four')

運算結(jié)果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':3,'two':2,'one':1}

1

None

注：get函數(shù)可以訪問字典中不存在的鍵，當(dāng)該鍵不存在是返回None

3.5?has_key函數(shù)：檢查字典中是否含有給出的鍵

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3}

printd

printd.has_key('one')

printd.has_key('four')

運算結(jié)果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':3,'two':2,'one':1}

True

False

3.6?items和iteritems函數(shù):items將所有的字典項以列表方式返回，列表中項來自（鍵，值），iteritems與items作用相似，但是返回的是一個迭代器對象而不是列表

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3}

printd

list=d.items()

forkey,valueinlist:

printkey,':',value

運算結(jié)果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':3,'two':2,'one':1}

three :3

two :2

one :1

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3}

printd

it=d.iteritems()

fork,vinit:

print"d[%s]="%k,v

運算結(jié)果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':3,'two':2,'one':1}

d[three]=3

d[two]=2

d[one]=1

3.7?keys和iterkeys：keys將字典中的鍵以列表形式返回，iterkeys返回鍵的迭代器

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3}

printd

printu'keys方法：'

list=d.keys()

printlist

printu'\niterkeys方法：'

it=d.iterkeys()

forxinit:

printx

運算結(jié)果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':3,'two':2,'one':1}

keys方法：

['three','two','one']

iterkeys方法：

three

two

one

3.8?pop函數(shù)：刪除字典中對應(yīng)的鍵

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3}

printd

d.pop('one')

printd

運算結(jié)果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':3,'two':2,'one':1}

{'three':3,'two':2}

3.9?popitem函數(shù)：移出字典中的項

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3}

printd

d.popitem()

printd

運算結(jié)果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':3,'two':2,'one':1}

{'two':2,'one':1}

3.10?setdefault函數(shù)：類似于get方法，獲取與給定鍵相關(guān)聯(lián)的值，也可以在字典中不包含給定鍵的情況下設(shè)定相應(yīng)的鍵值

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3}

printd

printd.setdefault('one',1)

printd.setdefault('four',4)

printd

運算結(jié)果：

{'three':3,'two':2,'one':1}

{'four':4,'three':3,'two':2,'one':1}

3.11?update函數(shù)：用一個字典更新另外一個字典

# _*_ coding:utf-8 _*_

d={

'one':123,

'two':2,

'three':3

}

printd

x={'one':1}

d.update(x)

printd

運算結(jié)果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':3,'two':2,'one':123}

{'three':3,'two':2,'one':1}

3.12?values和itervalues函數(shù)：values以列表的形式返回字典中的值，itervalues返回值得迭代器，由于在字典中值不是唯一的，所以列表中可以包含重復(fù)的元素

# _*_ coding:utf-8 _*_

d={

'one':123,

'two':2,

'three':3,

'test':2

}

printd.values()

運算結(jié)果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

[2,3,2,123]

Python對象的拷貝

Python賦值操作或函數(shù)參數(shù)傳遞，傳遞的永遠是對象引用（即內(nèi)存地址），而不是對象內(nèi)容。在Python中一切皆對象，對象又分為可變(mutable)和不可變(immutable)兩種類型。對象拷貝是指在內(nèi)存中創(chuàng)建新的對象，產(chǎn)生新的內(nèi)存地址。當(dāng)頂層對象和它的子元素對象全都是immutable不可變對象時，不存在被拷貝，因為沒有產(chǎn)生新對象。淺拷貝(Shallow Copy)，拷貝頂層對象，但不會拷貝內(nèi)部的子元素對象。深拷貝(Deep Copy)，遞歸拷貝頂層對象，以及它內(nèi)部的子元素對象。

Python中一切皆對象，對象就像一個塑料盒子， 里面裝的是數(shù)據(jù)。對象有不同類型，例如布爾型和整型，類型決定了可以對它進行的操作?，F(xiàn)實生活中的"陶器"會暗含一些信息（例如它可能很重且易碎，注意不要掉到地上）。

對象的類型還決定了它裝著的數(shù)據(jù)是允許被修改的變量（可變的mutable）還是不可被修改的常量（不可變的immutable）。你可以把不可變對象想象成一個透明但封閉的盒子：你可以看到里面裝的數(shù)據(jù)，但是無法改變它。類似地，可變對象就像一個開著口的盒子，你不僅可以看到里面的數(shù)據(jù)，還可以拿出來修改它，但你無法改變這個盒子本身，即你無法改變對象的類型。

對象拷貝是指在內(nèi)存中創(chuàng)建新的對象，產(chǎn)生新的內(nèi)存地址。

淺拷貝(Shallow Copy)，拷貝頂層對象，但不會拷貝內(nèi)部的子元素對象。

2.1.1. 頂層是mutable，子元素全是immutable

當(dāng)頂層對象是mutable可變對象，但是它的子元素對象全都是immutable不可變對象時，如[1, 'world', 2]

① 創(chuàng)建列表對象并賦值給變量a

② 導(dǎo)入copy模塊，使用copy.copy()函數(shù)淺拷貝a，并賦值給變量b

③ 修改變量a的子元素a[0] = 3，由于整數(shù)是不可變對象，所以并不是修改1變?yōu)?，而是更改a[0]指向?qū)ο?

當(dāng)頂層對象是 mutable可變對象 ，但子元素也存在 mutable可變對象 時，如 [1, 2, ['hello','world']]

① 淺拷貝 copy.copy() 只拷貝了頂層對象，沒有拷貝子元素對象['hello','world']，即a[2]和b[2]指向同一個列表對象

② 修改a[2][1] = 'china'，則b[2][1] = 'china'

當(dāng)頂層對象是immutable不可變對象，同時它的子元素對象也全都是immutable不可變對象時，如(1, 2, 3)

變量a與變量b指向的是同一個元組對象，沒有拷貝

當(dāng)頂層對象是immutable不可變對象時，但子元素存在mutable可變對象時，如(1, 2, ['hello','world'])

變量a與變量b指向的是相同的元組對象，并且a[2]與b[2]指向同一個列表，所以修改a[2][1]會影響b[2][1]

深拷貝(Deep Copy)，遞歸拷貝頂層對象，以及它內(nèi)部的子元素對象

當(dāng)頂層對象是mutable可變對象，但是它的子元素對象全都是immutable不可變對象時，如[1, 'world', 2]

變量a與變量b指向不同的列表對象，修改a[0]只是將列表a的第一個元素重新指向新對象，不會影響b[0]

當(dāng)頂層對象是mutable可變對象，但子元素也存在mutable可變對象時，如[1, 2, ['hello','world']]

深拷貝既拷貝了頂層對象，又遞歸拷貝了子元素對象，所以a[2]與b[2]指向了兩個不同的列表對象(但是列表對象的子元素初始指定的字符串對象一樣)，修改a[2][1] = 'china'后，它重新指向了新的字符串對象（內(nèi)存地址為140531581905808），不會影響到b[2][1]

當(dāng)頂層對象是immutable不可變對象，同時它的子元素對象也全都是immutable不可變對象時，如(1, 2, 3)

變量a與變量b指向的是同一個元組對象，不存在拷貝

當(dāng)頂層對象是immutable不可變對象時，但子元素存在mutable可變對象時，如(1, 2, ['hello','world'])

變量a與變量b指向的是不同的元組對象，同時a[2]與b[2]指向不同的列表對象，所以修改a[2][1]不會影響b[2][1]

使用=是賦值，即將列表對象的引用也賦值給變量b，可以將列表對象想像成一個盒子，變量a相當(dāng)于這個盒子上的標(biāo)簽，執(zhí)行b = a后，相當(dāng)于再在這個盒子上貼上b標(biāo)簽，a和b實際上指向的是同一個對象。因此，無論我們是通過a還是通過b來修改列表的內(nèi)容，其結(jié)果都會作用于雙方。

b/c/d都是a的復(fù)制，它們都指向了不同的列表對象，但是沒有拷貝子元素，a[2]和b[2]/c[2]/d[2]指向同一個列表， 相當(dāng)于淺拷貝的效果

使用分片[:]操作，a和b其實是指向同一個元組，而且沒有拷貝子元素，a[2]和b[2]也指向同一個列表，相當(dāng)于淺拷貝的效果

同列表類似，可以使用字典的copy()函數(shù)或者轉(zhuǎn)換函數(shù)dict()

變量a與變量b/c指向不同的字典，但是沒有拷貝子元素，a['jobs']和b['jobs']/c['jobs']指定同一個列表， 相當(dāng)于淺拷貝的效果

同列表類似，可以使用集合的copy()函數(shù)或者轉(zhuǎn)換函數(shù)set()

變量a與變量b/c指向不同的集合，而集合的元素必須是hashable，所以修改集合a不會影響到b/c

python 中如何實現(xiàn)對文件的復(fù)制、粘貼

file類中沒有提供專門的文件復(fù)制函數(shù)，因此只能通過使用文件的讀寫函數(shù)來實現(xiàn)文件的復(fù)制。這里僅僅給出范例：

src = file("myfile.txt", "w+")

temp = ["hello world! \n"]

src.writelines(temp)

src.close()

src = file("myfile.txt", "r+")

des = file("myfile2.txt", "w+")

des.writelines(src.read())

src.close()

des.close()

shutil模塊是另一個文件，目錄的管理接口，提供了一些用于復(fù)制文件，目錄的函數(shù)。copyfile（）函數(shù)可以實現(xiàn)文件的拷貝，聲明如下：

copyfile（src， des）

文件的剪切可以使用move（）函數(shù)模擬，聲明如下：

move（src，des）

功能：移動一個文件或者目錄到指定的位置，并且可以根據(jù)參數(shù)des重命名移動后的文件。

Python3 & 淺拷貝與深拷貝

在Python中對象的賦值（=）其實就是對象的引用。即：當(dāng)創(chuàng)建一個對象，把它賦值給另一個變量時，python并沒有拷貝這個對象，只是拷貝了這個對象的引用而已。

Python中對象的拷貝分為：淺拷貝(copy)和深拷貝(deepcopy)。

淺拷貝：拷貝了最外圍的對象本身，內(nèi)部的元素都只是拷貝了一個引用而已。也就是，將原對象在內(nèi)存中引用地址拷貝過來，然后讓新的對象指向這個地址?？梢允褂谩?”或列表自帶的copy()函數(shù)(如list.copy()），或使用copy模塊的copy()函數(shù)。

深拷貝：外圍和內(nèi)部元素都進行了拷貝對象本身，而不是引用。即把對象復(fù)制一遍，并且該對象中引用的其他對象也同時復(fù)制，完全得到一個新的一模一樣的對象，對新對象里的值進行修改不會影響原有對象，新對象和原對象完全分離開。深拷貝只能使用copy模塊中deepcopy()函數(shù)，使用前要導(dǎo)入：from copy import deepcopy。

Python中對象分為不可變對象 、可變對象。

不可變對象：一旦創(chuàng)建就不可修改的對象，例如：字符串、元組、數(shù)字

可變對象：可以修改的對象，例如：列表、字典。

其中Python中的切片可以應(yīng)用于：列表、元組、字符串，但不能應(yīng)用于字典。

而深淺拷貝，可應(yīng)用于序列（列表、元組、字符串），也可應(yīng)用于字典。

其中不可變對象，不管是深拷貝還是淺拷貝，地址值在拷貝后的值都是一樣的。

以下以元組（不可變類型）為例

從上述示例可以看出：

不可變對象類型，沒有被拷貝的說法，即便是用深拷貝，查看id的話也是一樣的，如果對其重新賦值，也只是新創(chuàng)建一個對象，替換掉舊的而已。

所以不可變類型，不管是深拷貝還是淺拷貝，地址值和拷貝后的值都是一樣的。

以下以列表（可變類型）為例

第一種方法：使用=號淺拷貝

輸出結(jié)果：

第二種方法：使用copy淺拷貝

輸出結(jié)果：

第三種方法：使用deepcopy深拷貝

輸出結(jié)果：

從上述示例可以看出：

=淺拷貝：值相等，地址相等

copy淺拷貝：值相等，地址不相等

deepcopy深拷貝：值相等，地址不相等

總結(jié)：

1，深淺拷貝都是對源對象的復(fù)制，占用不同的內(nèi)存空間。

2，不可變類型的對象，對于深淺拷貝毫無影響，最終的地址值和值都是相等的。

3，可變類型的對象，使用=淺拷貝時， 值相等，地址相等，對新對象里的值進行修改同時會影響原有對象;使用copy淺拷貝時值相等，地址不相等;使用deepcopy深拷貝時值相等，地址不相等?？梢钥闯鲠槍勺冾愋蚦opy淺拷貝和deepcopy深拷貝，對新對象里的值進行修改不會影響原有對象。

Python中的賦值，淺拷貝和深拷貝的區(qū)別

賦值(=)，就是創(chuàng)建了對象的一個新的引用，修改其中任意一個變量都會影響到另一個。

淺拷貝：創(chuàng)建一個新的對象，但它包含的是對原始對象中包含項的引用(如果用引用的方式修改其中一個對象，另外一個也會修改改變){1,完全切片方法;2，工廠函數(shù)，如list();3，copy模塊的copy()函數(shù)}

深拷貝：創(chuàng)建一個新的對象，并且遞歸的復(fù)制它所包含的對象(修改其中一個，另外一個不會改變){copy模塊的deep.deepcopy()函數(shù)}

分享題目：python中復(fù)制函數(shù) Python復(fù)制
瀏覽地址：http://muchs.cn/article44/hheohe.html

成都網(wǎng)站建設(shè)公司_創(chuàng)新互聯(lián)，為您提供關(guān)鍵詞優(yōu)化、動態(tài)網(wǎng)站、虛擬主機、用戶體驗、品牌網(wǎng)站設(shè)計、企業(yè)網(wǎng)站制作

廣告

聲明：本網(wǎng)站發(fā)布的內(nèi)容（圖片、視頻和文字）以用戶投稿、用戶轉(zhuǎn)載內(nèi)容為主，如果涉及侵權(quán)請盡快告知，我們將會在第一時間刪除。文章觀點不代表本網(wǎng)站立場，如需處理請聯(lián)系客服。電話：028-86922220；郵箱：631063699@qq.com。內(nèi)容未經(jīng)允許不得轉(zhuǎn)載，或轉(zhuǎn)載時需注明來源： 創(chuàng)新互聯(lián)