學習python，從入門到放棄（8）

阿新 • • 發佈：2022-03-10

學習python，從入門到放棄（8）

字典的內建方法

按 key 取值

取出字典中的值只要知道鍵就可以取出了，字典的鍵就相當於列表的索引值，字典的索引值取出來的是 key 。

d1 = {
    'name': 'jason',
    'age': 18,
    'hobbies': ['play game', 'basketball']
}
print(d1['name'])  # jason

但是用上述方法的時候，當鍵不存在時，會報錯，從而影響所有的程式碼，所以當涉及到字典取值時，更加推薦使用 .git() 方法。

d1 = {
    'name': 'jason',
    'age': 18,
    'hobbies': ['play game', 'basketball']
}
print(d1.get('name'))  # jason  鍵存在
print(d1.get('xxx'))  # None  鍵不存在不會報錯 而是返回None
print(d1.get('xxx', '這個鍵不存在'))  # 第二個引數不寫預設返回None，寫了則返回寫了的
print(d1.get('name', '這個鍵不存在'))  # 如果鍵存在 則不需要使用到第二個引數

修改值

字典屬於可變型別，屬於可以修改它的值，不會改變它的記憶體地址。

d1 = {
    'name': 'jason',
    'age': 18,
    'hobbies': ['play game', 'basketball']
}
print(id(d1))  # 1921058287336
d1['name'] = 'jasonDSB'  # 鍵存在是修改值
print(d1, id(d1))
# {'name': 'jasonDSB', 'age': 18, 'hobbies': ['play game', 'basketball']} 1921058287336

新增鍵值對

可以使用上面修改值的方法，當鍵存在時，是修改值，當鍵不存在時，就是新增鍵值對。

d1 = {
    'name': 'jason',
    'age': 18,
    'hobbies': ['play game', 'basketball']
}
print(d1)
# {'name': 'jason', 'age': 18, 'hobbies': ['play game', 'basketball']}
d1['name'] = 'jasonDSB'  # 鍵存在是修改值
print(d1)
# {'name': 'jasonDSB', 'age': 18, 'hobbies': ['play game', 'basketball'], 'pwd': 123}
d1['pwd'] = 123  # 鍵不存在則是新增一個鍵值對
print(d1)
# {'name': 'jasonDSB', 'age': 18, 'hobbies': ['play game', 'basketball'], 'pwd': 123}

統計鍵值對個數

當用與統計個數時，自然而然就能想到 len() 函數了。

d1 = {
    'name': 'jason',
    'age': 18,
    'hobbies': ['play game', 'basketball']
}
print(len(d1))  # 3

成員運算

與索引一樣，也只能判斷key的存在，不能判斷值是否存在。

d1 = {
    'name': 'jason',
    'age': 18,
    'hobbies': ['play game', 'basketball']
}
print('jason' in d1)  # False
print('name' in d1)  # True

刪除鍵值對

昨天也學過一個刪除列表的方法，同樣的也能刪除字典的鍵值對。

d1 = {
    'name': 'jason',
    'age': 18,
    'hobbies': ['play game', 'basketball']
}
del d1['name']
print(d1)  # {'age': 18, 'hobbies': ['play game', 'basketball']}
print(d1.pop('age'))  # 18  彈出
print(d1)  # {'hobbies': ['play game', 'basketball']}

其實還有一個使用頻率較低的方法 .popitem() 可以隨機彈出一個鍵值對。

d1 = {
    'name': 'jason',
    'age': 18,
    'hobbies': ['play game', 'basketball']
}
d1.popitem()
print(d1)  # {'name': 'jason', 'age': 18}

獲取字典

獲取鍵

.key() 用於獲取字典的鍵，獲取的內容相當於一個列表，可以用索引取值。

d1 = {
    'name': 'jason',
    'age': 18,
    'hobbies': ['play game', 'basketball']
}
print(d1.keys())  # dict_keys(['name', 'age', 'hobbies'])

獲取值

.values() 就對應字典中的值，取出的內容也可以看作是列表。

d1 = {
    'name': 'jason',
    'age': 18,
    'hobbies': ['play game', 'basketball']
}
print(d1.values())  # dict_values(['jason', 18, ['play game', 'basketball']])

獲取鍵值對

.items() 可以獲取字典的鍵值對，這個就相當於一個列表裡套著元組。

d1 = {
    'name': 'jason',
    'age': 18,
    'hobbies': ['play game', 'basketball']
}
print(d1.items())  # dict_items([('name', 'jason'), ('age', 18), ('hobbies', ['play game', 'basketball'])])

更新字典

.update() 用於更新字典，和新增字典差不多，也是鍵存在則修改值，鍵不存在則新增鍵值對。

dic = {'k1': 'jason', 'k2': 'Tony', 'k3': 'JY'}
dic.update({'k1': 'JN', 'k4': 'xxx'})
print(dic)  # {'k1': 'JN', 'k2': 'Tony', 'k3': 'JY', 'k4': 'xxx'}

.setdefault() 也有這樣的功能，但是它可以返回新增的或者已經有的值。

dic = {'k1': 111, 'k2': 222}
print(dic.setdefault('k3', 333))  # 333
print(dic)
#  {'k1': 111, 'k2': 222, 'k3': 333}
print(dic.setdefault('k1', '嘿嘿嘿'))  # 111
print(dic)
#  {'k1': 111, 'k2': 222, 'k3': 333}

快速生成字典

可以使用 .fromkeys() 快速生成字典。

dic = dict.fromkeys(['k1', 'k2', 'k3'], [])
print(dic)  # {'k1': [], 'k2': [], 'k3': []}

但是要注意，這樣創建出來的字典，三個鍵都指向同一個列表，當修改其中一個時，三個鍵的值也會一起修改。

dic = dict.fromkeys(['k1', 'k2', 'k3'], [])
print(dic)  # {'k1': [], 'k2': [], 'k3': []}
dic['k1'].append(111)
print(dic)  # {'k1': [111], 'k2': [111], 'k3': [111]}

元組的內建方法

型別轉換

元組被稱為不可變的列表，所以和列表一樣支援for迴圈的資料型別都可以轉成元組。

# print(tuple(11))  # 報錯
# print(tuple(11.11))  # 報錯
print(tuple('jason'))  # ('j', 'a', 's', 'o', 'n')
print(tuple([11,22,33,44]))  # (11, 22, 33, 44)
print(tuple({'name':'jason'}))  # ('name',)
print(tuple({11,22,33,44}))  # (33, 11, 44, 22)
# print(tuple(True))  # 報錯

特性

當元組內只有一個元素的時候，型別識別會將它識別為該元素的型別，所以建立列表時一定要在元素的後面加上逗號。
```
t1 = (11,)
print(type(t1))  # tuple
t2 = (11)
print(type(t2))  # int
t3 = (11.11)
print(type(t3))  # float
t4 = ('jason')
print(type(t4))  # str
```
所以為了避免造成這樣的後果，所以要養成在建立可以儲存多個數據的型別的資料時，在後面加一個逗號的習慣。
方法

元組被稱為不可變的列表，所以使用方法也和列表一樣，索引取值、切片、間隔、統計個數、成員運算、統計出現個數都與列表一樣，這裡就不多贅述了。但是要注意元組內的元素是不可以修改記憶體地址的。如果元組中的元素中有列表，可以在該列表中新增元素，因為列表屬於可變型別，修改列表中的元素並沒有修改列表的記憶體地址，所以可以正常新增。
```
tt = (11, 22, 33, [11, 22])
print(id(tt[-1]))  # 2171015870600
tt[-1].append('heiheihei')
print(id(tt[-1]))  # 2171015870600
print(tt)  # (11, 22, 33, [11, 22, 'heiheihei'])
```

集合內建方法

型別轉換

集合可以轉換字串、列表、字典、和元組，但是要注意集合內的型別只能是不可變型別。

print(set(11))  # 報錯
print(set(11.11))  # 報錯
print(set('jason'))  # {'o', 'j', 'n', 's', 'a'}
print(set([11,22,33,44]))  # {33, 11, 44, 22}
print(set({'name':'jason'}))  # {'name'}
print(set((11,22,33)))  # {33, 11, 22}
print(set(True))  # 報錯

去重

集合內是不會出現重複的元素的，所以當轉化為集合時，就會主動去除相同的元素。

s1 = {1,1,1,1,1,1,2,2,2,2,2,1,2,3,2,2,1,2,3,2,3,4,3,2,3}
print(s1)  # {1, 2, 3, 4}
l = ['a', 'b', 1, 'a', 'a']
s1 = set(l)
l = list(s1)
print(l)  # ['a', 'b', 1]

關係運算

可以判斷兩個群體間的關係

f1 = {'jason', 'kevin', 'tony', 'jerry'}  # 小李的好友列表
f2 = {'jason', 'tom', 'jerry', 'jack'}  # 小王的好友列表
# 1.求兩個人的共同好友
print(f1 & f2)  # {'jerry', 'jason'}
# 2.求小李的單獨好友
print(f1 - f2)  # {'kevin', 'tony'}
# 3.求兩個人所有的好友
print(f1 | f2)  # {'kevin', 'jack', 'tom', 'jason', 'jerry', 'tony'}
# 4.求兩個人各自的好友
print(f1 ^ f2)  # {'jack', 'tony', 'tom', 'kevin'}

垃圾回收機制

python底層針對空間的申請和釋放都是設計好的，方便程式設計師使用

引用計數

python會將引用計數為0的資料清除，引用計數就是記憶體中資料身上繫結的變數名的個數。
標記清除

當記憶體空間即將溢位的時候，python會自動啟動應急機制，停止程式的執行，檢查值的引用計數並給計數為 0 的資料打上標記，然後一次性清理掉。
分代回收

根據值存在的時間長短，將值劃分為三個等級。
1. 檢測機制每隔 5s 來一次
2. 檢測機制每隔 1min 來一次
3. 檢測機制每隔 5min 來一次
檢測為 0 就會被刪除。