拆分 sub del range 分享 集合 pre clear iss

1、數據類型的補充

　　1、1 元組

　　　　當元組裏面只有一個元素且沒有逗號時，則該數據的數據類型與括號裏面的元素相同。

tu1 = (‘laonanhai‘)
tu2 = (‘laonanhai‘)
print(tu1, type(tu1))
print(tu2, type(tu2),)

tu1 = (1)
tu2 = (1,)
print(tu1, type(tu1))
print(tu2, type(tu2))

tu1 = ([1, 2, 3])
tu2 = ([1, 2, 3],)
print(tu1, type(tu1))
print(tu2, type(tu2))

　　1、2 list 列表

　　　　在循環一個列表時，最好不要改變列表的大小，會影響你的最終結果。

　　　　li = [111, 222, 333, 444, 555,]，索引為奇數的所有元素全部刪除。

　　　　方法一：

l1 = [111, 222, 333, 444, 555, ]
del l1[1::2]
print(l1)

　　　　方法二（錯誤展示）：

l1 = [111, 222, 333, 444, 555, ]
for index in range(len(l1)):
    print(‘刪除之前的index:%s‘ % index)
    print(‘刪除之前的l1:%s‘ % l1)
    if index % 2 == 1:
        del l1[index]
    print(‘刪除之後的index:%s‘ % index)
    print(‘刪除之後的l1:%s‘ % l1)
print(l1)

　　　　方法三（倒著刪）：

l1 = [111, 222, 333, 444, 555, ]
for index in range(len(l1) - 1, -1, -1):
    if index % 2 == 1:
        del l1[index]
print(l1)

　　　　方法四（自己做的）：

l1 = [111, 222, 333, 444, 555, 666, 777, 888, 999, ]
i = len(l1)
count = 1
s = int(len(l1)/2)
for j in range(s):
    del l1[count]
    count += 1
print(l1)

　　1、3 字典

　　　　1、3、1 dict.fromkeys(A, B)　　A為可叠代對象，B任意。創建一個字典，叠代A的最小元素為鍵，B為值。

dic = dict.fromkeys(‘abc‘, 666)
print(dic)

dic = dict.fromkeys([11, 22, 33], 666)
print(dic)

dic = dict.fromkeys([1, 2, 3], [])
dic[1].append(666)
print(dic)

　　　　1、3、2 在循環字典時，最好不要改變字典的大小，會影響結果或者報錯。

　　　　錯誤示例：

dic = {‘k1‘: ‘v1‘, ‘k2‘: ‘v2‘, ‘k3‘: ‘v3‘, ‘name‘: ‘alex‘}
for i in dic:
    if ‘k‘ in i:
        del dic[i]
print(dic)

dic = {‘k1‘: ‘v1‘, ‘k2‘: ‘v2‘, ‘k3‘: ‘v3‘, ‘name‘: ‘alex‘}
l1 = []
for key in dic:
    if ‘k‘ in key:
        l1.append(key)
    print(l1)
for key in l1:
    del dic[key]
print(dic)

　　1、4 數據類型的轉換

　　　　str ------> list：

　　　　　　split

　　　　list ----->str：

　　　　　　join

　　　　tuple ------> list：

tu1 = (1, 2, 3)
l1 = list(tu1)
print(l1)

　　　　list ------> tuple：

tu1 = (1, 2, 3)
l1 = list(tu1)
tu2 = tuple(l1)
print(tu2)

　　　　dic ------> list：

　　　　　　list(dic)　　列表中只有key。

dic = {‘k1‘: ‘v1‘, ‘k2‘: ‘v2‘,‘k3‘: ‘v3‘,}
l1 = list(dic)
print(l1)
print(list(dic.keys()))
print(list(dic.values()))
print(list(dic.items()))

　　　　0， ‘‘，[]， {}，() ------> bool都是False。

print(bool(0))
print(bool(‘‘))
print(bool(()))
print(bool([]))
print(bool({}))

print(bool([0, 0, 0]))

2、set 集合

set1 = {1, 2, 3, ‘abc‘, (1, 2, 3), True, }
print(set1)

　　2、1 去重

　　　　集合去重。

set2 = {11, 11, 11, 22}
print(set2)

　　　　列表的去重。

l1 = [11, 11, 22, 22, 33, 33, 33, 44]
l2 = list(set(l1))
l2.sort()
print(l2)

　　2、2 增

　　　　__.add(‘A‘)　　A為添加的內容，隨機添加。

set1 = {‘alex‘, ‘WuSir‘, ‘RiTiAn‘, ‘egon‘, ‘barry‘}
set1.add(‘太白‘)
print(set1)

　　　　__.update(‘A‘)　　A為添加的可叠代內容，將A拆分為最小單元然後叠代添加。

set1 = {‘alex‘, ‘WuSir‘, ‘RiTiAn‘, ‘egon‘, ‘barry‘}
set1.update(‘abc‘)
print(set1)

set1 = {‘alex‘, ‘WuSir‘, ‘RiTiAn‘, ‘egon‘, ‘barry‘}
set1.update([111, 2222, 333])
print(set1)

　　2、3 刪

　　　　__.remove(‘A‘)　　按元素刪除。A為需要刪除的內容。

set1 = {‘alex‘, ‘WuSir‘, ‘RiTiAn‘, ‘egon‘, ‘barry‘}
set1.remove(‘RiTiAn‘)
print(set1)

　　　　__.pop()　　隨機刪除，有返回值。

set1 = {‘alex‘, ‘WuSir‘, ‘RiTiAn‘, ‘egon‘, ‘barry‘}
print(set1.pop())
print(set1)

　　　　__.clear()　　清空集合。　　空集合為set()。

set1 = {‘alex‘, ‘WuSir‘, ‘RiTiAn‘, ‘egon‘, ‘barry‘}
set1.clear()
print(set1)

　　　del __　　刪除集合。

set1 = {‘alex‘, ‘WuSir‘, ‘RiTiAn‘, ‘egon‘, ‘barry‘}
del set1
print(set1)

　　2、4 查

　　　　for循環。

set1 = {‘alex‘, ‘WuSir‘, ‘RiTiAn‘, ‘egon‘, ‘barry‘}
for i in set1:
    print(i)

　　2、5 交集

　　　　交集：__ & __　或者　__.intersection(__)

set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
set3 = set1 & set2
print(set3)

set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
set3 = set1.intersection(set2)
print(set3)

　　2、6 並集

　　　　並集：__ | __ 或者 __.union(__)

set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
set3 = set1 | set2
print(set3)

set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
set3 = set1.union(set2)
print(set3)

　　2、7 差集

　　　　差集：__ - __ 或者 __.difference(__)

set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
set3 = set1 - set2
print(set3)　　# set1獨有的

set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
set3 = set1.difference(set2)　　# set1獨有的
print(set3)

　　2、8 反交集

　　　　反交集：__ ^ __ 或者 __.symmetric_difference(__)

set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
set3 = set1 ^ set2
print(set3)

set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
set3 = set1.symmetric_difference(set2)
print(set3)

　　2、9 子集

　　　　子集：__ < __ 或者 __.issubset(__)

set1 = {1, 2, 3}
set2 = {1, 2, 3, 4, 5, 6}
print(set1 < set2)　　# True  set1 是set2 的子集

set1 = {1, 2, 3}
set2 = {1, 2, 3, 4, 5, 6}
print(set1.issubset(set2))　　# True  set1是set2的子集

　　2、10 超集

set1 = {1, 2, 3}
set2 = {1, 2, 3, 4, 5, 6}
print(set2 > set1)　　# set2 是 set1 的超集

set1 = {1, 2, 3}
set2 = {1, 2, 3, 4, 5, 6}
print(set2.issuperset(set1))　　# set2 是 set1 的超集

　　　　frozenset（）　　frozenset是凍結的集合，它是不可變的，存在哈希值，好處是它可以作為字典的key，也可以作為其它集合的元素。缺點是一旦創建便不能更改，沒有add，remove方法。　　

set1 = frozenset({1, 2, 3, ‘alex‘})
print(set1)

3、深淺copy

　　　　對於賦值運算來說，指向的都是同一個內存地址，一變都變。

l1 = [1, 2, 3]
l2 = l1
l3 = l2
l3.append(666)
print(l1, l2, l3)

　　3、1 淺copy

　　　　copy.（）　　淺copy

l1 = [11, 22, 33]
l2 = l1.copy()
l1.append(666)
print(l1, id(l1))
print(l2, id(l2))

　　　　當列表內層列表增加元素時，淺copy跟隨變化。內層的列表同樣是同一個地址。

　　　　對於淺copy來說，第一層創建的是新的內存地址，從第二層開始，指向的都是同一個內存地址，所以，對於第二層以及更深的層數來說，保持一致性。

l1 = [11, 22, [‘barry‘, [55, 66]], [11, 22]]
l2 = l1.copy()
l1[2].append(‘alex‘)
print(l1, id(l1))
print(l2, id(l2))
print(l1, id(l1[-1]))
print(l2, id(l2[-1]))

　　3、2 深copy

　　　　import copy

import copy
l1 = [11, 22, 33]
l2 = copy.deepcopy(l1)
l1.append(666)
print(l1, id(l1))
print(l2, id(l2))

import copy
l1 = [11, 22, [‘barry‘]]
l2 = copy.deepcopy(l1)
l1[2].append(‘alex‘)
print(l1, id(l1[-1]))
print(l2, id(l2[-1]))

　　　　深copy 完全獨立。

l1 = [1, 2, 3]
l2 = [1, 2, 3]
l1.append(666)
print(l1, id(l1))
print(l2, id(l2))

　　對於切片來說，這是淺copy。

l1 = [1, 2, 3, 4, 5, 6, [11, 22]]
l2 = l1[:]
l1.append(666)
print(l1, l2)

l1 = [1, 2, 3, 4, 5, 6, [11, 22]]
l2 = l1[:]
l1[-1].append(666)
print(l1, l2)

Python全棧__數據類型的補充、集合set、深淺copy