python之數據類型補充、集合、深淺copy


1、內容回顧
代碼塊: 一個函數,一個模塊,一個類,一個文件,交互模式下,每一行就是一個代碼塊。
is == id
id()查詢對象的內存地址
== 比較的是兩邊的數值。
is 比較的是兩邊的內存地址。
小數據池:
前提:int,str,bool
1,節省內存。
2,提升性能和效率。
小數據池是什麼?
在內存中,建立一個'池',提早存放了 -5 ~256 的整數,必定規則的字符串和bool值。
後續程序中,若是設置的變量指向的是小數據池的內容,那麼就不會再內存中從新建立。python


小數據池與代碼塊的關係。
同一個代碼塊:python在執行時,遇到了初始化對象命令,他會將這個變量名和數值放到一個字典中,
再次遇到他會從這字典中尋找。
不一樣代碼塊:python在執行時,直接從小數據池中尋找,知足條件id相同。
編碼:
python3x:git

英文:
str: 表現形式:s1 = 'hello'
內部編碼方式: unicode網絡

bytes:表現形式:s1 = b'hello'
內部編碼方式: 非unicode
中文:
str: 表現形式:s1 = '小白'
內部編碼方式: unicodeapp

bytes:表現形式:s1 = b'\xe2\xe2\xe2\xe2\xe2\xe2'
內部編碼方式: 非unicode
只有當你想要存儲一些內容到文件中,或者經過網絡傳輸時,纔要用的bytes類型函數


str --->bytes: encode
bytes--->str: decode




補充:post

複製代碼
s1 = '小黑'
b1 = s1.encode('gbk')
print(b1)            #gbk的bytes類型

# gbk的bytes類型 -----> utf-8的bytes類型,正常狀況是這樣轉換:
s2 = b1.decode('gbk')     # 先按照對應的編碼方式 解碼成字符串(unicode)
b2 = s2.encode('utf-8')    # 再編碼成utf-8的bytes
print(b2)
複製代碼

 

非中文的字符串還能夠這樣解碼:性能

複製代碼
s1 = 'xiaoming'
b1 = s1.encode('gbk')     #gbk的bytes類型

s2 = b1.decode('utf-8')    #能夠按照utf-8的形式解碼
print(s2)

# 上面代碼能成立:由於utf-8 gbk,unicode等編碼的英文字母,數字,特殊字符都是映射的ASCII碼。
複製代碼

 

 

2、基礎數據類型補充
一、元組:
若是元組中只有一個數據,且沒有逗號,那麼該"元組"的數據類型與裏面的數據類型一致
不然,該數據類型就是元組測試

複製代碼
tu1 = (1)
print(tu1,type(tu1))  # 1 <class 'int'>

tu1 = (1,)
print(tu1,type(tu1))  # (1,) <class 'tuple'>

tu2 = ('hello')
print(tu2,type(tu2))  # hello <class 'str'>

tu2 = ('hello',)
print(tu2,type(tu2))  # ('hello',) <class 'tuple'>
複製代碼

 


二、列表:
列表與列表能夠相加(就是拼接)
l1 = [1,2,3]
l2 = ['aa','bb']
l3 = l1 + l2
print(l3) --->[1, 2, 3, 'aa', 'bb']this


li = [11, 22, 33, 44, 55, 66, 77, 88]
將列表中索引爲奇數的元素,所有刪除.
也許剛接觸的時候會有人這麼寫:編碼

複製代碼
li = [11, 22, 33, 44, 55, 66, 77, 88]
# 問題代碼1:
for i in li:
    if li.index(i) % 2 == 1:
        li.remove(i)
print(li)


# 問題代碼2:
for i in range(len(li)):
    if i % 2 == 1:
        li.pop(i)
print(li)
複製代碼

 

可是你會發現這樣作並不能實現結果,要麼報錯,要麼實現不了預想的結果,爲何呢?
這是由於:在循環一個列表時,若是對列表中的某些元素進行刪除,
那麼此元素後面的全部元素就會向前進一位,他們的索引和長度就會發生變化。

因此正確的方法能夠這樣寫:

複製代碼
li = [11, 22, 33, 44, 55, 66, 77, 88]
# 方法一:切片+步長刪除
del li[1::2]
print(li)


# 方法二:
l2 = []
for i in range(len(li)):
    if i % 2 == 0:
        l2.append(li[i])
li = l2
print(li)

# 方法三:倒着刪除
for index in range(len(li)-1, -1, -1):
    if index % 2 == 1:
        li.pop(index)
print(li)
複製代碼

總結:在循環一個列表時,最好不要對此列表進行改變大小(增刪)的操做。


三、字典:
建立字典的方式:
(1)直接建立:dic = {'name':'hello','age':18}
(2)dic = dict({'name':'hello','age':18})
(3)dic = dict.fromkeys([1,2,3],'hello')      #迭代建立(第一個參數是可迭代對象,str list dict等)
結果: {1: 'hello', 2: 'hello', 3: 'hello'}

陷阱:
(1)
dic = dict.fromkeys([1,2,3],'hello')
print(dic)
print(id(dic[1]))
print(id(dic[2]))
print(id(dic[3]))
結果:

{1: 'hello', 2: 'hello', 3: 'hello'}
1604999043984
1604999043984
1604999043984


(2)
dic = dict.fromkeys([1,2,3],[])
print(dic)
這樣建立的是值爲空列表的字典:
{1: [], 2: [], 3: []}


dic[1].append('nihao')
print(dic)
print(id(dic[1]))
print(id(dic[2]))
print(id(dic[3]))
結果:
{1: ['nihao'], 2: ['nihao'], 3: ['nihao']}
2347486287880
2347486287880
2347486287880

 

dic[2].append('I am fine')
print(dic)
print(id(dic[1]))
print(id(dic[2]))
print(id(dic[3]))
結果:
{1: ['nihao', 'I am fine'], 2: ['nihao', 'I am fine'], 3: ['nihao', 'I am fine']}

2347486287880
2347486287880
2347486287880

結論:dict.fromkeys()方法迭代建立的字典,迭代的鍵都是指向同一個內存地址(值相同)

 

 

 

 

複製代碼
dic = {'key1': 'value1', 'key2': 'value2', 'k3': 'v3', 'name': 'aaa'}
# 將dic的鍵中含有k元素的全部鍵值對刪除。
# 錯誤代碼:
for key in dic:
    if 'k' in key:
        dic.pop(key)
print(dic)
# 這樣寫會報錯dictionarychangedsizeduringiteration
# 這是由於在循環一個字典時,不能改變字典的大小,不然就會報錯。



# 正確方法能夠:
l1 = []
for key in dic:
    if 'k' in key:
        l1.append(key)
for key in l1:  # 第二次循環的是含有'k'的全部鍵組成的一個列表,並在循環列表的時候刪除字典裏的鍵值對
    dic.pop(key)
print(dic)
複製代碼

 


數據類型的轉換。
'''
int str bool 三者轉換
str <---> bytes
str <---> list
dict.keys() dict.values() dict.items() list()
tuple <---> list
dict ---> list
'''

str ---> list:split()
s1 = 'aa bb cc'
l1 = s1.split()
print(l1)

list ---> str:join() 此list中的元素所有是str類型才能夠轉換
l1 = ['aa', 'bb', 'cc']
s2 = ' '.join(l1)
print(s2)

list ---> tuple
l1 = [1,2,3]
tu1 = tuple(l1)
print(tu1)

tuple ---> list
tu2 = (0,2,3)
l1 = list(tu2)
print(l1)


dict ---> list
dic1 = {'name': 'alex', 'age': 1000}
l1 = list(dic1)
l2 = list(dic1.keys())
l3 = list(dic1.values())
l4 = list(dic1.items())
print(l1)
print(l2)
print(l3)
print(l4)

 


3、集合set
set:
{'aa','bb',1,2,3}
集合要求裏面的元素必須是不可變的數據類型可是集合自己是可變的數據類型。
集合裏面的元素不重複(自然去重),無序
主要用途:
1,去重。
2,關係測試。

set1 = {'abc', [1,2], 1,2,3}     # 這個是錯誤的   由於集合要求裏面的元素必須是不可變的數據類型,所以這裏會報錯(列表是可變的數據類型)
set2 = {'aa', 'bb'}           #直接定義
set3 = set({'aa', 'bb'})    #set()方法
print(set2)

list去重 *****
l1 = [1,1,2,3,4,4,3,2,1,5,5]
set1 = set(l1)        #先把列表轉換成集合,自動去重
l2 = list(set1)        #再把集合轉換成列表
print(l2)


set1 = {'hello','handsome','boy','you','good'}

set1.add('女神')
print(set1)

set1.update('abc')    #update:迭代着增長
print(set1)


set1.remove('hello') # 刪除一個元素
print(set1)

set1.pop() # 隨機刪除一個元素
print(set1)

set1.clear() # 清空集合
print(set1)

del set1 # 刪除集合
print(set1)

關係測試

set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}

交集(& 或者 intersection)
print(set1 & set2)                    # {4, 5}
print(set1.intersection(set2))   # {4, 5}

並集(| 或者 union)
print(set1 | set2)              #{1, 2, 3, 4, 5, 6, 7, 8}
print(set1.union(set2))

反交集(^ 或者 symmetric_difference)
print(set1 ^ set2)                  # {1, 2, 3, 6, 7, 8}
print(set1.symmetric_difference(set2))

差集(- 或者 difference)
print(set1 - set2)            # {1, 2, 3}
print(set1.difference(set2))
print(set2 - set1)           #{8, 6, 7}

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

超集
print(set2 > set1)
print(set2.issuperset(set1))

frozenset不可變集合,讓集合變成不可變類型。
set1 = {1,2,3}
set2 = frozenset(set1)
print(set2)                 # 不可變的數據類型。 ***

 

 

4、深淺copy
賦值運算
l1 = [1,2,3]
l2 = l1
l1.append(666)
print(l2)
print(id(l1))
print(id(l2))    #是同一個地址,l2 = l1只是把l2指向了l1的地址,l1改變,l2也改變

 

淺copy(只針對列表,字典,集合):數據(列表)第二層開始能夠與原數據進行公用
深copy(引用copy模塊,任意數據類型均可深copy):徹底獨立的copy一份數據,與原數據沒有關係

淺copy
l1 = [1,2,3]
l2 = l1.copy()
l1.append(666)
print(l2)                #第一層是獨立的:[1, 2, 3]

 

l1 = [1,2,3,[22,]]
l2 = l1.copy()
l1[-1].append(666)
print(l1,l2)       #第二層開始與原數據公用:[1, 2, 3, [22, 666]] [1, 2, 3, [22, 666]]

print(id(l1))   #2357463048008
print(id(l2))  # 2357463013768
print(id(l1[-1]))  # 2357463047816
print(id(l2[-1]))  # 2357463047816

 

 

 

 


深copy
import copy
l1 = [1,2,3,[22,]]
l2 = copy.deepcopy(l1)
print(l1,l2)   # [1, 2, 3, [22]]    [1, 2, 3, [22]]
l1[-1].append(666)  
print(l1)   # [1, 2, 3, [22, 666]]

print(l2)   # [1, 2, 3, [22]]

 

 

 

 


切片屬於淺copy
l1 = [1,2,3,[22,33]]
l2 = l1[:]
# l1.append(666)
l1[-1].append(666)
print(l2)  # [1, 2, 3, [22, 33, 666]]

相關文章
相關標籤/搜索