day3——基本數據類型int, bool, str,list,tuple,dict
- 2019 年 11 月 3 日
- 筆記
基本數據類型(int, bool, str,list,tuple,dict)
一.python基本數據類型
1. int 整數. 主要用來進行數學運算
2. str 字元串, 可以保存少量數據並進行相應的操作,用雙引號或單引號或三引號括起來
3. bool 判斷真假, True, False
4. list 存儲大量數據.用[ ]表示
5. tuple 元組, 不可以發生改變，只讀列表 用( )表示
6. dict 字典, 保存鍵值對, 一樣可以保存大量數據{key:value}
7. set 集合, 保存大量數據. 不可以重複. 其實就是不保存value的dict
二. 整數(int)
在python3中所有的整數都是int類型. 但在python2中如果數據量比較大. 會使用long類型.
在python3中不存在long類型
整數可以進行的操作:
bit_length(). 計算整數在記憶體中佔用的二進位碼的長度
三. 布爾值(bool)
布爾只有兩個值. True,False. 一般是沒有什麼操作的.
類型轉換的問題:
想把xx轉換成yy. yy(xx)
可以表示False的內容:0, “”, [], tuple(), {}, None
所有的空都是False. 所有的非空是True
取值只有True, False. bool值沒有操作.
str int int(str)
int str str(int)
int bool bool(int). 0是False 非0是True
bool int int(bool) True是1, False是0
str bool bool(str) 空字元串是False, 不空是True
bool str str(bool) 把bool值轉換成相應的”值”
四. 字元串 (str)
字元串，由單引號或雙引號或三引號’,”,”’,闊起來的內容就是字元串，字元串是不可變的數據類型.不論你執行任何操作. 源字元串是不會改變的, 每次操作都會返回新字元串
1..字元串相關操作：
- upper() 轉換成大寫
- stript() 去掉空白
- replace(old, new) 把xxx替換成xxxx
- split() 切割. 返回列表. 用多長的刀. 就要損失掉多少
- startswith() 判斷是否以xxx開頭
- find(), count(), index()
- len() 計算字元串長度. python的內置函數
2. for循環
for 變數 in 可迭代對象:
循環體, 也存在break和continue
else:
當循環結束的時候會執行
3. 切片和索引
3.1索引從0開始, 使用[下標]可以獲取到每一個字元, 還可以倒著數，切記索引是從0開始的。
1 # 012345678 2 3 s1 = "python最牛B" 4 5 print(s1[0]) # 獲取第0個 6 7 print(s1[1]) 8 9 print(s1[2]) 10 11 print(s1[3]) 12 13 print(s1[4]) 14 15 print(s1[5]) 16 17 print(s1[6]) 18 19 print(s1[7]) 20 21 print(s1[8]) 22 23 print(s1[9]) # 沒有9, 越界了,會報錯 24 25 print(s1[-1]) # -1 表示倒數. 26 27 print(s1[-2]) # 倒數第二個
3.2切片, 我們可以使用下標來截取部分字元串的內容
語法: str[start: end]
切片: [起始位置:結束位置:步長]
規則: 顧頭不顧尾, 從start開始截取. 截取到end位置. 但不包括end，默認從左到右取值，當步長為負可以從右往左取值
1 s2 = "python最牛B" 2 print(s2[0:3]) # 從0獲取到3. 不包含3. 結果: pyt 3 print(s2[6:8]) # 結果 最牛 4 print(s2[6:9]) # 最大是8. 但根據顧頭不顧腚, 想要取到8必須給9 5 print(s2[6:10]) # 如果右邊已經過了最大值. 相當於獲取到最後 6 print(s2[4:]) # 如果想獲取到最後. 那麼最後一個值可以不給. 7 print(s2[-1:-5]) # 從-1 獲取到 -5 這樣是獲取不到任何結果的. 從-1向右數. 你怎麼數也數不到-5 8 print(s2[-5:-1]) # 牛b, 取到數據了. 但是. 顧頭不顧尾. 怎麼取最後一個呢? 9 print(s2[-5:]) # 什麼都不寫就是最後了 10 print(s2[:-1]) # 這個是取到倒數第一個 11 print(s2[:]) # 原樣輸出
跳著截取
# 跳著取, 步長
1 s1 = "python最牛B" 2 3 print(s2[1:5:2]) # 從第一個開始取, 取到第5個,每2個取1個, 結果: yh, 分析: 1:5=>ytho => yh 4 5 print(s2[:5:2]) # 從頭開始到第五個. 每兩個取一個 6 7 print(s2[4::2]) # 從4開始取到最後. 每兩個取一個 8 9 print(s2[-5::2]) # 從-5取到最後.每兩個取一個 10 11 print(s2[-1:-5]) # -1:-5什麼都沒有. 因為是從左往右獲取的. 12 13 print(s2[-1:-5:-1]) # 步長是-1. 這時就從右往左取值了 14 15 print(s2[-5::-3]) # 從倒數第5個開始. 到最開始. 每3個取一個, 結果oy
步長: 如果是整數, 則從左往右取. 如果是負數. 則從右往左取. 默認是1
切片語法:
str[start:end:step]
start: 起始位置
end: 結束位置
step:步長
4. 字元串的相關操作方法
切記, 字元串是不可變的對象, 所以任何操作對原字元串是不會有任何影響的
1. capitalize大小寫轉來轉去
1 a = "python" 2 3 a.capitalize() 4 5 print(a) # 輸出發現並沒有任何的變化. 因為這裡的字元串本身是不會發生改變的. 需要我們重新獲取 6 7 b = a.capitalize() 8 9 print(b)
2.大小寫的轉換
1 a = "python" 2 3 b = a.lower() # 全部轉換成小寫 4 5 print(b) 6 7 b1 = a.upper() # 全部轉換成大寫 8 9 print(b1) 10 11 # 應用, 校驗用戶輸入的驗證碼是否合法 12 13 verify_code = "abDe" 14 15 user_verify_code = input("請輸入驗證碼:") 16 17 if verify_code.upper() == user_verify_code.upper(): 18 19 print("驗證成功") 20 21 else: 22 23 print("驗證失敗") 24 25 ret = a.swapcase() # 大小寫互相轉換 26 27 print(ret)
3.字元串居中
1 a = "Python" 2 3 b = a.center(10, "*") # 拉長成10, 把原字元串放中間.其餘位置補* 4 5 print(b)
4.更改tab的長度
1 a = "Yong jietpython" 2 3 print(a) 4 5 print(a.expandtabs()) # 可以改變t的長度, 默認長度更改為8
5.去空格strip左右兩端的空格lstrip去掉左邊空格rstrip去掉右邊空格
1 a = " Yong jie haha" 2 3 b= a.strip() # 去掉左右兩端的空格 4 5 print(b) 6 7 b1= a.lstrip() # 去掉左邊空格 8 9 print(b1) 10 11 b2= a.rstrip() # 去掉右邊空格 12 13 print(b2)
例題:應用模擬用戶登錄. 忽略用戶輸入的空格
1 username = input("請輸入用戶名:").strip() 2 3 password = input("請輸入密碼: ").strip() 4 5 if username == 'YongJie' and password == 'root': 6 7 print("登錄成功") 8 9 else: 10 11 print("登錄失敗")
指定元素去掉的元素
1 a = "abcdefgabc" 2 3 print(a.strip("abc")) # defg 也可以指定去掉的元素,
字元串替換
1 a = "python_C_JAVA_vb_PHP" 2 3 b = a.replace('vb', '牛') # 把vb替換成牛 4 5 print(a) # "python_C_JAVA_vb_PHP" 切記, 字元串是不可變對象. 所有操作都是產生新字元串返回 6 7 print(b) # "python_C_JAVA_牛_PHP" 8 b1 = a.replace('y', 'nb', 1) # 把y替換成nb, 替換1個 9 10 print(b1) #pnbthon_C_JAVA_vb_PHP
字元串切割
1 a = 'python,PHP,C,java,css' 2 3 4 5 b = a.split(",") # 字元串切割, 根據,進行切割切割出來的是列表 6 7 print(b) #['python', 'PHP', 'C', 'java', 'css'] 8 a1 = """詩人 9 10 學者 11 12 感嘆號 13 14 渣渣""" 15 16 print(a1.split("n")) # 用n切割 17 18 ['詩人', '', '學者', '', '感嘆號', '', '渣渣']
格式化輸出
1 a = "我叫%s, 今年%d歲了, 我喜歡%s" % ('YJ', 19, 'Python') # 第一種寫法 2 3 print(a) 4 5 a1 = "我叫{}, 今年{}歲了, 我喜歡{}".format("YJ", 19, "Python") # 按位置格式化 6 7 print(a1) 8 9 a2 = "我叫{0}, 今年{2}歲了, 我喜歡{1}".format("YJ", "Python", 19) # 指定位置 10 11 print(a2) 12 13 a3 = "我叫{name}, 今年{age}歲了, 我喜歡{singer}".format(name="YJ", singer=Python", age=19) # 指定關鍵字,推薦使用這種 14 15 print(a3)
查找
1 a = "我叫YJ, 我喜歡python, java, c等程式語言" 2 b = a.startswith("YJ") # 判斷是否以YJ開頭 3 print(b) 4 b1 = a.startswith("我叫YJ") # 判斷是否以我叫YJ開頭 5 print(b1)
1 a = "我叫YJ, 我喜歡python, java, c等程式語言" 2 b2= a.endswith("語言") # 是否以'語言'結尾 3 4 print(b2) 5 6 b3= a.endswith("語言.") # 是否以'語言結尾 7 8 print(b3) 9 10 b4= a.count("p") # 查找"p"出現的次數 11 12 print(b4) 13 14 b5= a.find("java") # 查找'java'出現的位置 15 16 print(b5) 17 18 b6= a.find("我叫YJ") # 查找'我叫YJ'的位置, 如果沒有返回-1 19 20 print(a) 21 22 b8= a.index("我叫YJ") # 求索引位置. 注意. 如果找不到索引. 程式會報錯 23 24 print(b8)
條件判斷
1 a = "123.16" 2 3 a1 = "abc" 4 5 a2 = "_abc!@" 6 7 # 是否由字母和數字組成 8 9 print(a.isalnum()) 10 11 print(a1.isalnum()) 12 13 print(a2.isalnum()) 14 15 # 是否由字母組成 16 17 print(a.isalpha()) 18 19 print(a1.isalpha()) 20 21 print(a2.isalpha()) 22 23 # 是否由數字組成, 不包括小數點 24 25 print(a.isdigit()) 26 27 print(a.isdecimal()) 28 29 print(a.isnumeric()) # 這個比較牛B. 中文都識別. 30 31 print(a1.isdigit()) 32 33 print(a2.isdigit())
例題:用演算法判斷某一個字元串是否是小數
1 a = "-123.12" 2 3 a = a.replace("-", "") # 替換掉負號 4 5 if a.isdigit(): 6 7 print("是整數") 8 9 else: 10 11 if a.count(".") == 1 and not a.startswith(".") and not a.endswith("."): 12 13 print("是小數") 14 15 else: 16 17 print("不是小數")
計算字元串的長度
1 a = "我們不一樣,不一樣" 2 3 b = len(a) # 計算字元串的長度 4 5 print(b)
#注意: len()是python的內置函數所以訪問方式也不一樣你就記著len()和print()一樣就行了
迭代
我們可以使用for循環來便利(獲取)字元串中的每一個字元
語法:
for 變數 in 可迭代對象:
pass
可迭代對象: 可以一個一個往外取值的對象
1 a = "大家好, 我是YJ, 前端的小朋友們,你們好么?" 2 3 # 用while循環 4 5 index = 0 6 7 while index < len(a): 8 9 print(a[index]) # 利用索引切片來完成字元的查找 10 11 index = index + 1 12 13 # for循環, 把a中的每一個字元拿出來賦值給前面的c 14 15 for c in a: 16 17 print(c)
in有兩種用法:
1. 在for中. 是把每一個元素獲取到賦值給前面的變數
2. 不在for中. 判斷xxx是否出現在str中.
1 a = "大家好, 我是YJ, 前端的小朋友們,你們好么?" 2 3 print('YJ' in a) #True
例題:計算在字元串”I am YJ, I’m 19years old, I like Python!”
1 a = "I am YJ, I'm 19years old, I like Python!" 2 3 count = 0 4 5 for c in a: 6 7 if c.isdigit(): 8 9 count = count + 1 10 11 print(count) #2
list,tuple主要內容:
1. 列表
2. 列表的增刪改查
3. 列表的嵌套
4. 元組和元組嵌套
5. range
一. 列表
1. 什麼是列表:
列表是一個可變的數據類型, 列表是python的基礎數據類型之一,列表由[]來表示, 每一項元素使用逗號隔開. 列表什麼都能裝. 能裝對象的對象,列表可以裝大量的數據
lst = [1, ‘python’, “程式設計師”, [1,8,0,”百度”], (“我”,”叫”, “元”, “組”), “abc”, {“我叫”:”dict字典”},{“我叫集合”,”集合”}]
列表相比於字元串. 不僅可以存放不同的數據類型. 而且可以存放大量的數據. 32位
python可以存放: 536870912個元素, 64位可以存放: 1152921504606846975個元素.而且列表是有序的(按照你保存的順序),有索引, 可以切片方便取值.
2. 列表的索引和切片
列表和字元串一樣，也有索引和切片，只不過切出來的內容是列表，索引的下標從0開始
列表的索引:
[起始位置:結束位置:步長]
1 lst = ["python", "Java", "PHP", "C", "VB"] 2 3 print(lst[0]) # 獲取第一個元素 4 5 print(lst[1]) 6 7 print(lst[2]) 8 9 lst[3] = "我很牛" # 注意. 列表是可以發生改變的. 這裡和字元串不一樣 10 11 print(lst) # ["python", "Java", "PHP", "我很牛", "VB"] 12 13 s = "華強北" 14 15 s[1] = "帥" #字元串不允許改變會報錯 16 print(s)
17 #TypeError: 'str' object does not support item assignment
列表的切片:
1 lst = ["python", "PHP", "JAVA", "C", "華強北"] 2 3 print(lst[0:3]) # ['python', 'PHP', 'JAVA'] 4 5 print(lst[:3]) # ['python', 'PHP', 'JAVA'] 6 7 print(lst[1::2]) # ['PHP', 'C'] 也有步長 8 9 print(lst[2::-1]) # ['JAVA', 'PHP', 'python'] 也可以倒著取 10 11 print(lst[-1:-3:-2]) # 倒著帶步長
二. 列表的增刪改查
增, 注意, list和str是不一樣的. lst可以發生改變. 所以直接就在原來的對象上進行了操作
1. append() 追加
2. insert(index, 元素) 在index位置添加元素
3. extend() 迭代添加
例:append() 追加
1 lst = ["Python", "JAVA", "PHP", "C"] #定義一個列表 2 3 print(lst) 4 5 lst.append("YJ") #添加YJ元素默認在後面添加 6 7 print(lst)
例:insert(index, 元素) 追加
1 lst = [] 2 3 while True: 4 5 content = input("請輸入你要錄入的語言, 輸入Q退出:") 6 7 if content.upper() == 'Q': 8 9 break 10 11 lst.append(content) 12 13 print("您添加的語言有:",lst) 14 15 lst = ["Python", "Java", "PHP"] 16 17 lst.insert(1, "YJ") # 在1的位置插入YJ. 原來的元素向後移動一位 18 19 print(lst)
例:extend() 迭代添加
1 lst = ["Python", "Java", "PHP"] 2 3 lst.extend(["YJ", "TX"]) 4 5 print(lst)
#['Python', 'Java', 'PHP', 'YJ', 'TX']
刪除
1. pop(index) 按照位置刪除元素
2.remove(元素) 直接刪除元素
3. clear() 清空列表
4. del 切片
1.pop(index) 按照位置刪除元素
1 lst = ["python", "PHP", "JAVA", "C", "華強北"] 2 3 deleted = lst.pop() # 刪除最後一個 4 5 print("被刪除的元素是：", deleted) 6 7 print(lst) 8 9 華強北 10 11 el = lst.pop(2) # 刪除2號元素 12 13 print(el) 14 15 JAVA 16 17 print(lst) 18 19 ['python', 'PHP', 'C', '華強北']
2.remove(元素) 直接刪除元素
1 lst = ["python", "PHP", "JAVA", "C", "華強北"] 2 3 lst.remove("華強北") # 刪除指定元素 4 5 print(lst) 6 7 ['python', 'PHP', 'C'] 8 9 # lst.remove("YJ") # 刪除不存在的元素會報錯 10 11 # print(lst) 12 13 # ValueError: list.remove(x): x not in list
3. clear() 清空列表
1 lst = ["python", "PHP", "JAVA", "C", "華強北"] 2 3 lst.clear() # 清空list 4 5 print(lst) 6 7 []
4. del 切片.
1 del lst[1:3] 2 3 print(lst) 4 5 ['python', 'C', '華強北']
修改
1.索引修改
1 lst = ["python", "PHP", "JAVA", "C", "華強北"] 2 3 lst[1] = "YJ" # 把1號元素修改成YJ 4 5 print(lst) 6 7 ['python', 'YJ', 'JAVA', 'C', '華強北']
2.切片修改
1 lst = ["python", "PHP", "JAVA", "C", "華強北"] 2 3 lst[1:4] = ["堅持","加油"] 4 5 print(lst) 6 7 ['python', '堅持', '加油', '華強北'] 8 9 lst[1:4] = ["程式設計師"] 10 11 print(lst) 12 13 ['python', '程式設計師']
查詢, 列表是一個可迭代對象, 所以可以進行for循環
1 lst = ["python", "PHP", "JAVA", "C", "華強北"] 2 3 for el in lst: 4 5 print(el) 6 7 python 8 PHP 9 JAVA 10 C 11 華強北
其他操作
1.count查詢出現的次數
1 lst = ["python", "PHP", "JAVA", "C", "華強北"] 2 3 c = lst.count("PHP") # 查詢PHP出現的次數 4 5 print(c) 6 7 1
2.sort() 排序 reverse=True降序
1 lst = [1, 11, 22, 2] 2 3 lst.sort() # 排序. 默認升序 4 5 print(lst) 6 7 [1, 2, 11, 22] 8 9 lst.sort(reverse=True) # 降序 10 11 print(lst) 12 13 [22, 11, 2, 1]
3. reverse() 翻轉
1 lst = ["python", "PHP", "JAVA", "C", "華強北"] 2 3 lst.reverse() 4 5 print(lst) 6 7 ['華強北', 'C', 'JAVA', 'PHP', 'python']
4.len() 求長度
1 lst = ["python", "PHP", "JAVA", "C", "華強北"] 2 3 a = len(lst) # 列表的長度 4 5 print(a) 6 7 5
三. 列表的嵌套
採用降維操作.一層一層的看就好.
1 lst = [1, "太帥", "yJ", ["PYTHON", ["可口可樂"], "雪碧"]] 2 3 # 找到yJ 4 5 print(lst[2]) 6 7 YJ 8 9 # 找到太帥和yJ 10 11 print(lst[1:3]) 12 13 ['太帥', 'yJ'] 14 15 # 找到太帥的帥字 16 17 print(lst[1][1]) 18 19 帥 20 21 # 將yJ拿到. 然後首字母大寫. 再扔回去 22 23 s = lst[2] 24 25 s = s.capitalize() 26 27 lst[2] = s 28 29 print(lst) 30 31 [1, '太帥', 'Yj', ['PYTHON', ['可口可樂'], '雪碧']] 32 33 # 簡寫 34 35 lst[2] = lst[2].capitalize() 36 37 print(lst) 38 39 [1, '太帥', 'Yj', ['PYTHON', ['可口可樂'], '雪碧']] 40 41 # 把太帥換成太丑 42 43 lst[1] = lst[1].replace("帥", "丑") 44 45 print(lst) 46 47 [1, '太丑', 'yJ', ['PYTHON', ['可口可樂'], '雪碧']]
四. 元組和元組嵌套
元組: 俗稱不可變的列表.又被成為只讀列表, 元組也是python的基本數據類型之一, 用小括弧括起來, 裡面可以放任何數據類型的數據, 查詢可以. 循環也可以. 切片也可以. 但就是不能改，如果元祖中只有一個元素就使用這樣的格式(元素, )
空元組: tuple()
元祖是一個可迭代對象, 可以使用for循環
1 tu = (1, "太帥", "YJ", "太牛", "hello") 2 3 print(tu) 4 5 (1, '太帥', 'YJ', '太牛', 'hello') 6 7 print(tu[0]) 8 9 1 10 11 print(tu[2]) 12 13 YJ 14 15 print(tu[2:5]) # 切片之後還是元組 16 17 ('YJ', '太牛', 'hello') 18 19 # for循環遍曆元組 20 21 for el in tu: 22 23 print(el) 24 25 1 26 27 太帥 28 29 YJ 30 31 太牛 32 33 hello
嘗試修改元組
1 tu = (1, "太帥", "YJ", "太牛", "hello") 2 3 # tu[1] = "程式設計師" # 報錯 TypeError: 'tuple' object does not support item assignment 4 5 tu = (1, "哈哈", [], "呵呵") 6 7 print(tu) 8 9 (1, '哈哈', [], '呵呵') 10 11 # tu[2] = ["fdsaf"] # 這麼改不行 12 13 tu[2].append("青青草原") # 可以改了. 沒報錯 14 15 tu[2].append("我最狂") 16 17 print(tu) 18 19 (1, '哈哈', ['青青草原', '我最狂'], '呵呵')
關於不可變, 注意: 這裡元組的不可變的意思是子元素不可變. 而子元素內部的子元素是可以變, 這取決於子元素是否是可變對象.
元組中如果只有一個元素. 一定要添加一個逗號, 否則就不是元組
1 tu = (1,) 2 3 print(type(tu)) 4 5 <class 'tuple'>
元組也有count(), index(), len()等方法.
五. range
range可以幫我們獲取到一組數據. 通過for循環能夠獲取到這些數據.
range(n) 從0到n-1
range(m,n) 從m到n-1
range(m,n,q) 從m到n-1 每q個取1個
綜上就是切片
1 for num in range(10): 2 3 print(num) 4 5 0 6 7 1 8 9 2 10 11 3 12 13 4 14 15 5 16 17 6 18 19 7 20 21 8 22 23 9
1 for num in range(1, 10, 2): #隔著來輸出步長為2 2 print(num) 3 4 1 5 6 3 7 8 5 9 10 7 11 12 9
1 for num in range(10, 1, -2): # 反著來, 和切片一樣 2 3 print(num) 4 5 10 6 7 8 8 9 6 10 11 4 12 13 2
六 range和for循環來獲取列表中的索引
for i in range(len(列表)):
i 索引
列表[i] 元素
七. dict字典主要內容:
1. 字典的簡單介紹
2. 字典增刪改查和其他操作
3. 字典的嵌套
一. 字典的簡單介紹
字典(dict)是python中唯一的一個映射類型.他是以{ }括起來的鍵值對組成. 在dict中key是唯一的. 在保存的時候, 根據key來計算出一個記憶體地址. 然後將key-value保存在這個地址中.這種演算法被稱為hash演算法, 所以, 切記, 在dict中存儲的key-value中的key’必須是可hash的,如果你搞不懂什麼是可哈希, 暫時可以這樣記, 可以改變的都是不可哈希的,那麼可哈希就意味著不可變. 這個是為了能準確的計算記憶體地址而規定的.
已知的可哈希(不可變)的數據類型: int, str, tuple, bool
不可哈希(可變)的數據類型: list, dict, set
語法 :{key1: value1, key2: value2….}
注意: key必須是不可變(可哈希)的. value沒有要求.可以保存任意類型的數據
創建一個合法字典:
1 dic = {123: 456, True: 999, "id": 1, "name": 'YJ', "age": 19, "stu": ['帥哥', '美女'], (1, 2, 3): '很666'} 2 3 print(dic[123]) 4 5 print(dic[True]) 6 7 print(dic['id']) 8 9 print(dic['stu']) 10 11 print(dic[(1, 2, 3)])
不合法字典如:
1 dic = {[1, 2, 3]: '嘿嘿嘿'} # list是可變的. 不能作為key 2 3 dic = {{1: 2}: "哈哈哈"} # dict是可變的. 不能作為key 4 5 dic = {{1, 2, 3}: '呵呵呵'} # set是可變的, 不能作為key
dict保存的數據不是按照我們添加進去的順序保存的. 是按照hash表的順序保存的. 而hash表
不是連續的. 所以不能進行切片工作. 它只能通過key來獲取dict中的數據
二. 字典的增刪改查和其他相關操作
1. 增加
1 dic = {} 2 3 dic['name'] = 'YJ' # 如果dict中沒有出現這個key, 就會新增⼀一個key-value的組合進dict 4 5 dic['age'] = 19 6 7 print(dic)
如果dict中沒有出現過這個key-value. 可以通過setdefault設置默認值
1 dic.setdefault('Python') # 也可以往裡面設置值. 2 3 dic.setdefault("Guido", "Python") # 如果dict中已經存在了. 那麼setdefault將不會起作用 4 5 print(dic)
2. 刪除
1 dic = {"stu":"hahah"} 2 a = dic.pop("stu") #指定鍵刪除 3 print(dic) 4 5 {} 6 7 del dic["stu"] #指定鍵刪除 8 print(dic) 9 10 {}
隨機刪除
1 ret = dic.popitem()
清空字典中的所有內容
1 dic.clear()
3. 修改
1 dic = {"id": 123, "name": 'YJ', "age": 19} 2 3 dic1 = {"id": 456, "name": "GUIDO", "ok": "wtf"} 4 5 dic.update(dic1) # 把dic1中的內容更更新到dic中. 如果key重名. 則修改替換. 如果不存在ket,則新增 6 7 8 9 print(dic) 10 11 {'id': 456, 'name': 'GUIDO', 'age': 19, 'ok': 'wtf'} 12 13 print(dic1) 14 15 {'id': 456, 'name': 'GUIDO', 'ok': 'wtf'}
在key, 則新增
1 print(dic) 2 3 {'id': 456, 'name': 'GUIDO', 'age': 19, 'ok': 'wtf'} 4 5 print(dic1) 6 7 {'id': 456, 'name': 'GUIDO', 'ok': 'wtf'}
4. 查詢
查詢一般用key來查找具體的數據.
1 print(dic['name']) 2 3 # print(dic['sylar']) # 報錯 4 5 print(dic.get("ok")) 6 7 print(dic.get("sylar")) # None 8 9 print(dic.get("sylar", "牛B")) # 牛B
5. 其他相關操作
1 dic = {"id": 123, "name": 'sylar', "age": 18, "ok": "科比"} 2 3 print(dic.keys()) # dict_keys(['id', 'name', 'age', 'ok']) #不用管它是什麼當成list來用就行 4 5 for key in dic.keys(): 6 7 print(key) 8 9 print(dic.values()) # dict_values([123, 'sylar', 18, '科⽐比']) 一樣也當list來用 10 11 for value in dic.values(): 12 13 print(value) 14 15 print(dic.items()) # dict_items([('id', 123), ('name', 'sylar'), ('age', 16 17 18), ('ok', '科比')]) #這個東西也是list. 只不過list中裝的是tuple 18 19 for key, value in dic.items(): # ?? 這個是解構 20 21 print(key, value) 22 23 # 解構 24 25 a, b = 1, 2 26 27 print(a, b) 28 29 (c, d) = 3, 4 30 31 print(c, d) 32 33 e, f = [1, 2, 3] # 解構的時候注意數量必須匹配 34 35 print(e, f)
三. 字典的嵌套
1 dic1 = { 2 3 "name": "YJ", 4 5 "age": 19, 6 7 "language": { 8 9 "name": 'Python', 10 11 "age": 28 12 13 } 14 15 } 16 17 print(dic1.get("language").get("name"))
練習:
dic1 = {
‘name’:[‘yJ’,2,3,5],
‘job’:’teacher’,
‘oldboy’:{‘YJ’:[‘python1′,’python2’,100]}
}
1，將name對應的列表追加一個元素’Python’。
2，將name對應的列表中的yJ首字母大寫。
3，oldboy對應的字典加一個鍵值對’YJ’,’加油’。
4，將oldboy對應的字典中的yJ對應的列表中的python2刪除。
2019年11月3日
