Python 中的字符串（str）、字典（dict）詳解及操作方法

一、字符串

在python中字符串是一種重要數據類型。其他數據類型分別為：

1. 數字-number -------- int、long、float、complex這幾種
2. 字符串-string -------- "使用引號"引起來的都是字符串
3. 元組-tuple ------------ (1,2)使用小括號引起來的元素，中間用逗號隔開.
   注意如果元組(v1, )中只有一個值，一定記得要用逗號隔開，不然就無法識別為元組了
4. 布爾值-bool --------- True及False
   以上四個為Python中的不可變對象，創建后就不能改變的量-->指該變量指向內存中的值不能被改變，當改變某個變量時候，由於其所指的值不能被改變，相當於把原來的值復制一份后再改變，這會開辟一個新的地址，變量再指向這個新的地址

---

5. 列表-list --------------- **[1, 2, 3] ['a', 'b', 'c']**中括號，里面的元素用逗號隔開 6. 字典-dict -------------- **{key1 : value1, key2 : value2}** 使用大括號＋鍵-值方式定義，鍵值之間使用 : 冒號，不同的鍵對值使用逗號分開

5、6皆為可變對象，指該對象所指向內存中的值可以被改變。

1.1 字符串的方法

1. str.capitalize() 會將首字母大寫
2. str.count(x, start=None, end=None) 統計str中的指定字符x的個數，start和end為起始位和結束位
3. str.center(num, [指定字符]) 將str字符串在num長度的字符中居中，str長度不夠則第二個參數為填充字符。同 "{0:[填充字符]^[長度]}".format(str) 一樣的效果
4. str.endswith("tr") 判定str是否為指定參數，這兒為"tr"結尾，是返回True 否False
5. str.find([指定字符]) 找到參數字符在str中的起始索引
6. str.isalnum() str是否為阿拉伯數字、字符，是返回True
7. str.isalpha() 是否為純英文
8. str.isdecimal() 是否為十進制數
9. str.isdigit() 是否為整數
10. str.isidentifier() 是否為合法標識符（變量名）
11. str.islower() 字符串是否全部小寫
12. str.lower() 將字符串小寫
13. str.isupper() 字符串是否為大寫
14. str.upper() 將字符串大寫
15. '[分隔符]'.join([iterable]) 如"+".join(['1', '2', '3'])結果為'1+2+3' 分隔符的join方法參數為可循環對象
16. str.ljust(num, '[填充符]') 擴展str長度到num，不夠的位置使用填充符從右往左填充
17. str_s.replace('s', 'S', 1) 替換目標字符，將小寫s替換為大寫S，只替換一個
18. str.split(sep=None) 將字符按照sep參數分割，列表形式返回分割后的元素
19. str.strip(chars=None) 重要默認移除字符串頭和尾的 space、\n、\t ，或者移除指定參數字符

>>> str_test = '\n/home/user/lina  \t'
>>> str_test = str_test.strip()      #去除首尾的space \n \t 
>>> str_test
'/home/user/lina'
>>> str_list = str_test.split('/')    #以 '/' 分割字符串
>>>str_list
['', 'home', 'user', 'lina']
>>> str_test .strip('/')   #去除首尾的‘/’
'home/user/lina'
>>>

二、字典

字典(dict)是python中唯一的一個映射類型.他是以{ }括起來的鍵值對組成. 在dict中key是唯一的，
在保存的時候, 根據key來計算出⼀一個內存地址然后將key-value保存在這個地址中。
這種算法被稱為hash算法, 所以, 切記, 在dict中存儲的key-value中的key必須是可hash的,
如果你搞不懂什什么是可哈希, 暫時可以這樣記, 可以改變的都是不可哈希的,
那么可哈希就意味着不可變. 這個是為了了能准確的計算內存地址⽽而規定的.

已知的可哈希(不可變)的數據類型: int, str, tuple, bool不可哈希(可變)的數據類型: list, dict, set（詳見開頭介紹python中的不可變對象）

字典其他語言中稱為map，使用鍵-值{key:value}方式存儲數據也讓其具有極高的查找速度
相比於List、tuple為什么會有如此高的查找速度呢？
設想我們現在使用list、tuple來存儲一個人的個人信息,一個列表存儲姓名，另一個列表內用元組存其他信息，用列表索引對應

>>> p_name = ['lina', 'josh', 'alex', 'linda', 'david']
>>> p_info = [(22, 'student', 'UA), (32, 'musician', 'Germany'), (33, 'worker', 'Austrilia'), (26, 'artist', 'Russia'), ('54', 'politician', 'UA')]
>>>

假設我們要查找到某人的具體信息，那么我們就必須先從p_name中拿到他的索引index_var = p_name.index(var)，然后拿着索引index_var到p_info中去p_info[index_var]拿到具體信息，第一次查找時，我們必須遍歷列表，這個過程列表元素少很快，當列表元素多了的時候，遍歷就很浪費時間了，第二次查找時就是可以用二分法了。而當用字典來存儲時，直接姓名哈希算法hash找到個人信息存儲地址--->

>>> p_info = {'lina': (22, 'student', 'UA),
... 'josh': (32, 'musician', 'Germany'),
... 'alex': (33, 'worker', 'Austrilia'),
... 'linda': (26, 'artist', 'Russia'),
... 'david': ('54', 'politician', 'UA')}
>>> p_info['josh']
(32, 'musician', 'Germany')

這樣通過名字作為索引，就可以一次直接查詢到，不用去遍歷整個keys，然后通過哈希算法根據key，算出value的存儲地址直接拿到value。幾乎不會隨着字典的增大而查找速度變慢 =
注意：創建或者添加時，key是唯一的不可重復。

2.1字典的增

2.1.1直接通過 dict[索引] = value 方式增加
優點：簡單方便   缺點：如果新增的key和已經存在的key重復，那就會直接更新該key對應的value
當然你也可以通過 key in dict 或者get()方法判斷，key是否已經存在字典中

>>> dict1 = {'name': 'lina'}
>>> dict1['age'] = 24
>>>dict1
{'name': 'lina', 'age': 24}
>>> 
>>> 'age' in dict1      #判斷字典中是否存在該key存在返回True，不存在False
True
>>> dict1.get('name')  #通過字典的get()方法拿到對應的key的value
'lina'
>>> dict1.get('job')  #當key不存在時返回None
>>>

2.1.2 dict.setdefault('key', value) 設置，增加新key-value
相比於第一種方式，這樣去增加值，當key不存在時，新增key-value，當key存在時，不做操作。避免了誤操作修改了重要數據

>>> dict2 = {'name': 'lina'}
>>> dict2.setdefault('age', 23)    #setdefault()安全設置key-value
23
>>> dict2
{'age': 23, 'name': 'lina'}
>>> dict2.setdefault('name', 'alex')   #嘗試用setdefault()設置已存在的key-value
'lina'
>>> dict2.get('name')   #可以看見，setdefault無法改變已經存在了的key-value
'lina'

2.2字典的刪除

2.2.1 del dict[key] python內置函數del 刪除
缺點：如果你不小心玩成del dict 這樣，那你就完了，整個字典都給你刪除了
2.2.2 dict.pop(key) 最常用的，標准刪除格式。通過dict.pop函數，刪除並返回value
安全刪除建議使用
2.2.3 dict.popitem() 隨機刪除，當沒看見
2.2.4 dict.clear() 清空字典所有元素

2.3字典的改、查

2.3.1 dict.updata(new_dict) 將一個新字典更新到原字典中，如果dict和new_dict 存在相同的key，就用新字典的key-value去更新原字典的value
2.3.2 dict[key]直接查詢，缺點當key不存在時，會直接報錯。建議使用dict.get(key) key存在直接返回value，不存在返回None

dict1 = {"k1": "v1",
         "k2": "v2",
         "k3": "v3"}

new_dict = {"k3": "vv3",
         "k4": "vv4"}

dict1.update(new_dict)
print(dict1)

#結果為：
{'k1': 'v1', 'k2': 'v2', 'k4': 'vv4', 'k3': 'vv3'}  #dict1中的k3-v3 更新為k3-vv3

#-------------------------------------------------------------------------------------------
#查
print(dict1["k1"])
print(dict1.get("k2")

#結果為
v1
v2

2.4 字典的遍歷

2.4.1 按照keys進行遍歷
語法：for key in dict:

>>> dict1 = {'a': 1, 'b': 2, 'c': 3}
>>> for key in dict1:
...     print("key:{0: <3}value:{1}".format(key, dict1.get(key)))
... 
key:a  value:1
key:b  value:2
key:c  value:3

2.4.2 按照dict.items() 遍歷
字典中的items 是一個個的元組，每一個元組是一個(key, valule) 的組合

dict1 = {"k1": 1,"k2": 2,"k3": 3}
for k,v in dict1.items():
    print(k,v)

#結果為
k3 v3
k1 v1
k2 v2

2.5 字典的輸出

2.5.1 輸出keys,， dict.keys()會輸出一個由keys組成的dict_keys對象，是類似列表格式，可用list(dict.keys())轉化為列表
2.5.2 輸出values , 同理keys一樣，是由values組成的一個dict_keys對象

>>> dict1 = {"k1": 1,"k2": 2,"k3": 3}
>>> dict1.keys()   #輸出keys
dict_keys(['k3', 'k2', 'k1'])
>>> list(dict1.keys())   #轉為list方法
['k3', 'k2', 'k1']
>>> dict1.values()  #輸出values
dict_values([1, 2, 3])