diff 末尾 .get rem efault 索引 一次 拼接 容器

1.拷貝

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

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

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

ls3 = deepcopy(ls) # 新開辟列表空間，ls列表中的不可變類型的地址直接拿過來，但是可變類型的地址一定重新開辟空間
4) 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}

4.字典的定義

# 空字典
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)

5.字典的操作

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)

6.集合類型

# 空集合：不能用{},因為用來標示空字典
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

學習總結（六）