第六章 數據類型——元組、字典、集合、數據類型的轉換

1.深淺拷貝

   值拷貝：應用場景最多
   ls = [1, 'abc', [10]]

   ls1 = ls # ls1直接將ls中存放的地址拿過來
   ls內部的值發生任何變化，ls1都會隨之變化

   ls2 = ls.copy() # 新開闢列表空間，但列表中的地址都是直接從ls列表中拿來
   ls內部的可變類型值發生改變，ls2會隨之變化

   ls3 = deepcopy(ls) # 新開闢列表空間，ls列表中的不可變類型的地址直接拿過來，可是可變類型的地址必定從新開闢空間
 ls內部的全部類型的值發生改變，ls3都不會隨之變化

 

2.元組類型

元組：能夠理解爲不可變的列表
 1.值能夠爲任意類型
 2.能夠存放多個值 - 能夠進行成員運算
 3.能夠存放重複的值 - 能夠計算成員出現的次數
 4.有序存儲 - 能夠經過索引取值，能夠切片


 經常使用操做
 1.索引取值
print(t1[1], type(t1[1]))
print(t1[-3])
​
 2.運算(拼接)
print((1, 2) + (2, 3))
​
 3.長度
print(len(t1))
​
 4.切片
print((2, 1, 3)[::-1])
​
 5.成員運算
print(True in t1)
print(False in t1)  # False == 0， t1中若是有0或False，該結果都是True
​
 6.for循環
for obj in t1:
    print(obj, end=" ")
print()
​
​
 方法
print(t1.count(0))  # 對象0在元組中出現的次數
​
print(t1.index(123, 4, len(t1))) # 對象0在區間4~末尾第一次出現的索引

3.字典類型

字典相關概念

 容器(集合)：存放多個值的變量
 單列容器(系統中的單列容器不少)：list | tuple
 雙列容器(map)：只有dict，存放數據 成對出現，dict存放數據採用 key-value鍵值對方式
​
​
 字典中的key能夠爲何類型：key必須爲不可變類型
       -- key是取value的惟一依據，key一旦被肯定，就須要惟一肯定(不能被改變)
 字典中的value能夠爲何類型：value能夠爲任意類型
       -- value是用來存放世間全部存在的數據
​
 key要確保惟一性，不能重複，值能夠重複，而且能夠被改變 => 字典爲可變類型
​
dic = {'a': 10, 1: 20, True: 30, (): 40}  # 1和True都是1，key具備惟一性，因此只保留最後一次值
print(dic)  # {'a': 10, 1: 30, (): 40}

 

字典的定義

# 空字典
d1 = {}
d2 = dict()
# 用map映射建立字典
d3 = dict({'a': 1, 'b': 1})
print(d3)
# 用關鍵字賦值方式
d4 = dict(name='Bob', age=18)  # 參數=左側的名字就是合法的變量名，都會被轉化爲字符串形式的key
print(d4)
# 建立有多個key值採用默認值的方式: 默認值不寫默認None，也能夠自定義
d5 = {}.fromkeys('abc', 0)
print(d5)

 

字典的操做

dic = {'a': 1, 'b': 2}
print(dic)
​
# 增: 字典名[key] = 值 => key已存在就是修改值，不存在就是新增值
dic['c'] = 3
print(dic)
# 改
dic['c'] = 30
print(dic)
# 查:字典名[key]
print(dic['c'])  # 只能查找已有的key，沒有崩潰
# 有默認值的查詢：有key取出對應value，沒有返還默認值，默認值能夠自定義
print(dic.get('d', 'http://www.baidu.com'))
# 刪
print(dic)
# 清空
# dic.clear()
# pop(k)刪除指定key的value並返還刪除的value
# res = dic.pop('a')
# 從dic末尾刪除，返還(key, value)造成的元組
res = dic.popitem()
print(dic, res)
​
​
# 其餘方法
# 更新: a有值覆蓋，c沒被新操做，帶下來，b爲新增，增長並賦值
dic = {'a': 1, 'c': 2}
d = {'a': 10, 'b': 20}
dic.update(d)
print(dic)  # {'a': 10, 'c': 2, 'b': 20}
​
# 帶默認值的新增: 新增key，key已有，啥事不幹，沒有添加key，值就是第二個參數
dic.setdefault('z', 100)
print(dic)
​
​
# 字典的循環
# 1.直接循環，就是循環獲得key
# for k in dic:
#     print(k)
​
# 2.循環keys
# print(dic.keys())
# for k in dic.keys():
#     print(k)
​
# 3.循環values
# print(dic.values())
# for v in dic.values():
#     print(v)
​
# 同時循環key和value (key, value)
print(dic.items())
# a, b = (1, 2)
# print(a, b)
# for res in dic.items():
#     print(res)
# 重點
for k, v in dic.items():
    print(k, v)
​
# 解壓賦值
# a, _, _, b = (1, 2, 3, 4)

 

集合類型

# 空集合：不能用{},由於用來標示空字典
s = set()
print(s, type(s))
​
# 概念：
# 1.set爲可變類型 - 可增可刪
# 2.set爲去重存儲 - set中不能存放重複數據
# 3.set爲無序存儲 - 不能索引取值
# 4.set爲單列容器 - 沒有取值的key
# 總結：set不能取值
​
# 增
s.add('1')
s.add('2')
s.add('1')
print(s)
s.update({'2', '3'})
print(s)
​
# 刪
# res = s.pop()
# print(res)
# s.remove('1')
# print(s)
s.clear()
print(s)
​
​
# set運算
# 交集：兩個都有 &
py = {'a', 'b', 'c', 'egon'}
lx = {'x', 'y', 'z', 'egon'}
print(py & lx)
print(py.intersection(lx))
​
# 合集：兩個的合體 |
print(py | lx)
print(py.union(lx))
​
# 對稱交集：拋出共有的辦法的合體 ^
print(py ^ lx)
print(py.symmetric_difference(lx))
​
# 差集：獨有的
print(py - lx)
print(py.difference(lx))
​
# 比較：前提必定是包含關係
s1 = {'1', '2'}
s2 = {'2'}
print(s1 < s2)

 

3.數據類型轉換 

1.哪些類型能夠轉化爲數字
res = int('10')
print(res)
res = int('-3')
print(res)
res = float('.15')
print(res)
res = float('-.15')
print(res)
res = float('-3.15')
print(res)
 做業：判斷全部能被轉換爲數字類型的字符串，並轉化

 2.數字轉化字符串
print(str(10))

 3.字符串與列表相互轉換 ******
s = 'abc123呵呵'
print(list(s)) # ['a', 'b', 'c', '1', '2', '3', '呵', '呵'] 沒有對應的 str(ls)
ls = ['a', 'b', 'c', '1', '2', '3', '呵', '呵']
n_s = ''.join(ls)
print(n_s) # 'abc123呵呵'

 s1 = 'a b c 1 2 3 呵 呵'
# res = s1.split() # 默認按空格拆
s1 = 'a b c 1 2 3 呵 呵'
res = s1.split()
print(res)

 必須掌握
s2 = 'ie=UTF-8&wd=你好帥'
res = s2.split('&')
print(res) # ['ie=UTF-8', 'wd=你好帥']

ls2 = ['ie=UTF-8', 'wd=你好帥']
n_s2 = '@'.join(ls2)
print(n_s2) # ie=UTF-8@wd=你好帥

 4.需求："ie=UTF-8&wd=你好帥" => [('ie', 'UTF-8'), ('wd', '你好帥')]
res = []
s4 = "ie=UTF-8&wd=你好帥"
ls4 = s4.split('&') # ['ie=UTF-8', 'wd=你好帥']
for ele in ls4: # v = ie=UTF-8 | wd=你好帥
k, v = ele.split('=') # k: ie v: UTF-8
res.append((k, v))
print(res)

 5.需求："ie=UTF-8&wd=你好帥" => {'ie': 'UTF-8', 'wd': '你好帥'}
res = {}
s5 = "ie=UTF-8&wd=你好帥"
ls5 = s5.split('&') # ['ie=UTF-8', 'wd=你好帥']
for ele in ls5: # v = ie=UTF-8 | wd=你好帥
k, v = ele.split('=') # k: ie v: UTF-8
res[k] = v
print(res)

6.需求：[('ie', 'UTF-8'), ('wd', '你好帥')] => {'ie': 'UTF-8', 'wd': '你好帥'}
res = {}
ls6 = [('ie', 'UTF-8'), ('wd', '你好帥')]
for k, v in ls6:
res[k] = v
print(res)

 7.list與tuple、set直接相互轉化 - 直接 類型()

# 8.需求：將漢字轉化爲數字
# 將 壹、貳、叄、肆、伍、陸、柒、捌、玖、拾、佰、仟
# 轉化爲 一、二、三、四、五、六、七、八、九、十、100、100
# 做業：壹仟捌佰玖拾叄 => 1893

num_map = {
'壹': 1,
'貳': 2,
'仟': 1000
}
ls8 = ['貳', '壹', '仟']
res = []
for v in ls8:
num = num_map[v] # 經過key去映射表拿到對應的值，完成 '貳' => 2
res.append(num)
print(res)