1、【List補充】

在循環(huán)一個列表時，最好不要使用元素和索引進行刪除操作，一旦刪除，索引會隨之改變，容易出錯。

如果想不出錯，可以采用倒著刪除的方法，因為倒著刪除進行的話，只是后面元素的位置發(fā)生了變化(位移)，但不影響前面元素的排列位置。

元組在只有一個元素時，需要加個逗號來防止岐義。

將列表中索引為奇數(shù)的元素進行刪除，有三種方法(思路):

第一種是最簡單的del加切片:

例：

li = ['老男孩', 'python', 'alex', 'wusir', 'egon', 'ritian', '女神']

del li[1::2]

print(li)和步長操作；

結果：['老男孩', 'alex', 'egon', '女神']

第二種是先挑選出索引為偶數(shù)的元素(因為反過來說要保留的是它們)，

加進一個新列表，再將新列表賦值給舊列表；

li = ['老男孩', 'python', 'alex', 'wusir', 'egon', 'ritian', '女神']

l1 =[]

for i in range(len(li)):

if i % 2 == 0:

l1.append(li[i])

li = l1

print(li)

結果：['老男孩', 'alex', 'egon', '女神']

第三種是通過for循環(huán)，通過range索引范圍找出奇數(shù)位置的元素來進行單個單個的del，但是要注意的是要將范圍倒過來進行操作，如下：

li = [11, 22, 33, 44, 55]

for i in range(len(li)-1, -1, -1):

if i % 2 == 1:

del li[i]

print(li)

結果：[11, 33, 55]

注意不要使用index查找元素來確定索引的方式，因為一旦列表中有多個同名的元素存在時，index就會導致錯誤，和你預想中的效果不一樣，index查找返回的是第一個找到的元素的索引位置。

2、【dict補充】

題：刪除以下字典中，鍵包含k的鍵值對。

dic = {'k1':'value1', 'k2':'value2', 'name':'wusir'}

假如我們試圖for遍歷鍵直接去刪除的話：

dic = {'k1':'value1', 'k2':'value2', 'name':'wusir'}

for i in dic:

print(i)

if 'k' in i:

del dic[i]

print(dic)

會出現(xiàn)如下報錯：

Traceback (most recent call last):

k1

File "E:/Python/day07/temp.py", line 20, in

for i in dic:

RuntimeError: dictionary changed size during iteration

這是因為，

在循環(huán)(迭代)字典時，是不能進行改變字典大小的操作的(增加或刪除此字典的鍵值對)。

故可行的是先將所有鍵取出放在一個列表中，再循環(huán)這個列表來進行刪除。

li =[]

for i in dic:

if 'k' in i:

li.append(i)

for k in li:

del dic[k]

print(dic)

{'name': 'wusir'}

以上代碼其實還可以優(yōu)化成不用先行創(chuàng)建空列表，而是直接list轉換查詢到的所有鍵的dict.keys()容器成列表，如下：

dic = {'k1':'value1', 'k2':'value2', 'name':'wusir'}

lis =list(dic.keys())

for key in lis:

if 'k' in key:

del dic[key]

print(dic)

另，數(shù)據(jù)轉換補充

tuple list

List(tuple)

tuple(list)

3、【集合set】

從事數(shù)據(jù)開發(fā)的可能常用到它

集合的樣子，如：set = {11, 22, 33}

集合：

數(shù)據(jù)類型：里面的元素不重復，無序(意味著沒有索引，不能改，可以增刪查)，它里面的元素是可hash的，但集合本身是不可哈希的，不能作為字典的key。

作用：

1、去重。

(面試必有一道去重題，不提算法的情況下，直接轉換成集合)

2、數(shù)據(jù)關系的測試。(兩個集合之間的交并集等)

li = [11,11,22,22,55,55,66,66,33,33,33,44]

li = list(set(li))

print(li)

增加：

set.add()

hum = {'槍兵', '弓箭手', '獅鷲', '劍士'}

hum.add('僧侶')

print(hum)

{'槍兵', '弓箭手', '僧侶', '獅鷲', '劍士'}

set.update(迭代增加)

hum = {'槍兵', '弓箭手', '獅鷲', '劍士'}

soldires = ['騎士', '天使', '僧侶']

hum.update(soldires)

print(hum)

{'劍士', '僧侶', '騎士', '獅鷲', '天使', '槍兵', '弓箭手'}

刪除：

set.remove()按照元素去刪除，刪除不存在的元素會引發(fā)異常

hum = {'槍兵', '弓箭手', '獅鷲', '劍士'}

hum.remove('槍兵')

print(hum)

{'獅鷲', '弓箭手', '劍士'}

set.discard()刪除集合指定的元素，刪除不存在的元素不會引發(fā)報錯(它什么都不做)

set.pop()隨機刪除(因為無序)，有返回值，返回被刪除的值

hum = {'槍兵', '弓箭手', '獅鷲', '劍士'}

print(hum.pop())

print(hum)

劍士

{'獅鷲', '弓箭手', '槍兵'}

set.clear() 清空集合【空集合表現(xiàn)為set()】

hum = {'槍兵', '弓箭手', '獅鷲', '劍士'}

hum.clear()

print(hum)

set()

del set 刪除整個集合

查：

for遍歷去查詢所有元素

for i in set：

print(i)

# 求交集 (求兩個集合中都有的元素)

set1 & set2

set1.intersection(set2)

例：

set1 = {1, 2, 3, 4, 5}

set2 = {4, 5, 6, 7, 1}

print(set1 & set2) # 顯示{1, 4, 5}

print(set1.intersection(set2)) # 顯示{1, 4, 5}

# 反交集 (反過來返回兩個集合中交集除外的元素)

set1 ^ set2

set1.symmetric_difference(set2)

例：

set1 = {1, 2, 3, 4, 5}

set2 = {4, 5, 6, 7, 1}

print(set1 ^ set2) # 顯示{2, 3, 6, 7}

print(set1.symmetric_difference(set2)) # 顯示{2, 3, 6, 7}

# 計算交集并更新成交集操作

intersection_update

set1 = {1, 2, 3, 4, 5}

set2 = {4, 5, 6, 7, 1}

set1.intersection_update(set2)

print(set1)

{1, 4, 5}

set1集合變成了交集的元素。

# 并集 (合并，相同的被覆蓋)

set1 | set2 (且去重)

set1.union(set2)

例：

set1 = {1, 2, 3, 4, 5}

set2 = {4, 5, 6, 7, 1}

print(set1 | set2)

print(set1.union(set2))

# 顯示：

{1, 2, 3, 4, 5, 6, 7}

{1, 2, 3, 4, 5, 6, 7}

# 并集計算并更新成并集

set1.update(set2)

set1 = {1, 2, 3, 4, 5}

set2 = {4, 5, 6, 7, 1}

set1.update(set2)

print(set1, set2)

{1, 2, 3, 4, 5, 6, 7} {1, 4, 5, 6, 7}

可以看到只有前者被替換成了并集。

# 差集 (前者減去后者中有的前者元素，所剩的集合)

set1 - set2

set2 - set1

set1.difference(set2)

例：

set1 = {1, 2, 3, 4, 5}

set2 = {4, 5, 6, 7, 1}

print(set1 - set2) #顯示{2, 3}

print(set2 - set1) #顯示{6, 7}

# 差集更新

set1.difference_update(set2)

set1 = {1, 2, 3, 4, 5}

set2 = {4, 5, 6, 7, 1}

set1.difference_update(set2)

print(set1, set2)

{2, 3} {1, 4, 5, 6, 7}

set1被替換成set1和set2的差集了。也就是它不但計算兩者的差集，同時還將差集結果替換前者集合。

# 對稱差集，計算兩兩之間的差集，返回的是合起來的差集結果集合

symmetric_difference()

set1 = {1, 2, 3, 4, 5}

set2 = {4, 5, 6, 7, 1}

print(set1.symmetric_difference(set2))

{2, 3, 6, 7}

# 子集 (返回bool值)

set1.issubset(set2)

set1 < set2

例：

set1 = {1, 2, 3, 4, 5}

set2 = {4, 5, 6, 7, 1}

print(set1 < set2) # 返回False

set3 = {33, 35, 38}

set4 = {21, 22, 33, 35, 38}

print(set3.issubset(set4))

# 返回True，set3是set4的子集，換言之，set4中的元素中包含有set3的所有元素。

# 超集

set2.issuperset(set1)

set2 > set1

例：

set3 = {33, 35, 38}

set4 = {21, 22, 33, 35, 38}

print(set3.issuperset(set4)) # False

print(set4 > set3) # True

# frozenset (冰凍集合)

冰凍集合是一種特殊的集合類型,也是集合(集合是列表的話,冰凍集合就是元組)

(將集合變成字典鍵，不可變類型的集合)

frozenset(set)

set3 = {33, 35, 38}

set4 = {21, 22, 33, 35, 38}

print(frozenset(set3), type(frozenset(set3)))

dic = {frozenset(set4):'test'} #轉化成字典鍵值

print(dic)

print(set3, type(set3))

frozenset({33, 35, 38})

{frozenset({38, 33, 35, 21, 22}): 'test'}

{33, 35, 38}

基本的集合推導式

>>> var ={'centos', 'openSUSE', 'Ubuntu', 'reahat'}

>>> result = {'*'+i+'*' for i in var}

>>> print(result)

{'*centos*', '*openSUSE*', '*Ubuntu*', '*reahat*'}

帶條件判斷的集合推導式

>>> result = {i for i in var if i !='centos'}

>>> print(result)

{'Ubuntu', 'openSUSE', 'reahat'}

多循環(huán)集合推導式

>>> colors = {'red', 'blue', 'pink'}

>>> sizes = {36, 37, 38, 39}

>>> result = {c + str(s) for c in colors for s in sizes}

>>> print(result)

{'pink37', 'red38', 'pink39', 'pink36', 'red37', 'blue39', 'blue38', 'blue37', 'blue36', 'pink38', 'red39', 'red36'}

# isdisjoint() 檢測2個集合是否不存在交集 存在交集則返回False

set1 = {1, 2, 3, 4, 5}

set2 = {4, 5, 6, 7, 1}

set3 = {8, 9, 10}

print(set1.isdisjoint(set2))

print(set2.isdisjoint(set3))

False

True

4、【深淺copy】淺談

# copy 不再是指向同一個內存空間，而是在內存中又開辟了新的另一個內存空間

l1 = [1, 2, 3]

l2 = l1.copy()

l1.append(4)

print(l1, l2)

#copy，對于淺copy來說，第一層創(chuàng)建的是新的內存地址，從第二層開始以及更深層來說，它們用的是同一個(會保持一致性)。

#對于切片來說，它也是一種淺copy

l1 = [1, 2, [1, 2, 3], 4]

l2 = l1.copy()

l1[2].append(5)

print (l1, l2)

# deep.copy 深copy

# 改變任意一個的任何元素，不管多少層嵌套(幾維)，它都是新開辟了內存空間，獨立存在的。

improt copy

l1 = [1, 2, [1, 2, 3], 4]

l2 = copy.deepcopy(l1)

#創(chuàng)建了一個一模一樣，但內存空間完全沒有關系的，

l1[2].append(5)

print(l1, l2)

print(id(l1[2]),id(l2[2])

Python中對象的賦值都是傳遞了對象引用(同一內存地址);

使用copy.copy()進行對象的淺拷貝，它復制了對象，但對于對象中的嵌套(多維)元素，依然使用原始的引用;

使用copy.deepcopy()進行深拷貝,可以做到復制一個容器(有嵌套)對象，

使它里面的所有元素(包含元素的子元素)都是開辟新的內存空間;

對于非容器類型(如數(shù)字、字符串、和其他'原子'類型的對象)沒有被拷貝一說,

因為對原字符串的操作都會生成新的字符串;

如果元祖變量只包含原子類型對象，則不能深拷貝。

5、編碼的補充

s = 'tiele'

s1 = s.encode('utf-8') unicode ---> utf-8 轉碼

s2 = s1.decode('utf-8') utf-8 --->unicode 解碼

gbk ----> utf-8

兩者不能直接進行轉換， 都需要借助unicode

s = 'tiele'

s1 = s.encode('gbk')

s2 = s1.decode('gbk')

s3 = s2.encode('utf-8')

或

s2 = s1.decode('gbk').encode('utf-8')

end

總結

以上是生活随笔為你收集整理的乐学python怎么样_铁乐学Python_day07_集合and浅谈深浅copy的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內容還不錯，歡迎將生活随笔推薦給好友。